/**
 *
 */
import Util;
import OpenApi;
import OpenApiUtil;
import EndpointUtil;

extends OpenApi;


init(config: OpenApi.Config){
  super(config);
  @endpointRule = '';
  
  checkConfig(config);
  @endpoint = getEndpoint('aiops', @regionId, @endpointRule, @network, @suffix, @endpointMap, @endpoint);
}

function getEndpoint(productId: string, regionId: string, endpointRule: string, network: string, suffix: string, endpointMap: map[string]string, endpoint: string) throws: string{
  if (!Util.empty(endpoint)) {
    return endpoint;
  }
  
  if (!Util.isUnset(endpointMap) && !Util.empty(endpointMap[regionId])) {
    return endpointMap[regionId];
  }
  return EndpointUtil.getEndpointRules(productId, regionId, endpointRule, network, suffix);
}

model AddAlgorithmRequest {
  algorithmId?: string(name='AlgorithmId'),
  algorithmType?: int32(name='AlgorithmType'),
  businessGroupId?: string(name='BusinessGroupId'),
  endTime?: long(name='EndTime'),
  expandInformation?: string(name='ExpandInformation'),
  indexId?: string(name='IndexId'),
  instanceId?: string(name='InstanceId'),
  operaUid?: string(name='OperaUid'),
  productType?: string(name='ProductType'),
  startTime?: long(name='StartTime'),
}

model AddAlgorithmResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model AddAlgorithmResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: AddAlgorithmResponseBody(name='body'),
}

async function addAlgorithmWithOptions(request: AddAlgorithmRequest, runtime: Util.RuntimeOptions): AddAlgorithmResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.algorithmId)) {
    query['AlgorithmId'] = request.algorithmId;
  }
  if (!Util.isUnset(request.algorithmType)) {
    query['AlgorithmType'] = request.algorithmType;
  }
  if (!Util.isUnset(request.businessGroupId)) {
    query['BusinessGroupId'] = request.businessGroupId;
  }
  if (!Util.isUnset(request.endTime)) {
    query['EndTime'] = request.endTime;
  }
  if (!Util.isUnset(request.expandInformation)) {
    query['ExpandInformation'] = request.expandInformation;
  }
  if (!Util.isUnset(request.indexId)) {
    query['IndexId'] = request.indexId;
  }
  if (!Util.isUnset(request.instanceId)) {
    query['InstanceId'] = request.instanceId;
  }
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  if (!Util.isUnset(request.productType)) {
    query['ProductType'] = request.productType;
  }
  if (!Util.isUnset(request.startTime)) {
    query['StartTime'] = request.startTime;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'AddAlgorithm',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function addAlgorithm(request: AddAlgorithmRequest): AddAlgorithmResponse {
  var runtime = new Util.RuntimeOptions{};
  return addAlgorithmWithOptions(request, runtime);
}

model AddBusinessGroupRequest {
  aliUid?: string(name='AliUid'),
  businessGroupDesc?: string(name='BusinessGroupDesc'),
  businessGroupName?: string(name='BusinessGroupName'),
  createUser?: string(name='CreateUser'),
  instanceList?: [ string ](name='InstanceList'),
  operaUid?: string(name='OperaUid'),
  resourceType?: int32(name='ResourceType'),
  updateUser?: string(name='UpdateUser'),
}

model AddBusinessGroupShrinkRequest {
  aliUid?: string(name='AliUid'),
  businessGroupDesc?: string(name='BusinessGroupDesc'),
  businessGroupName?: string(name='BusinessGroupName'),
  createUser?: string(name='CreateUser'),
  instanceListShrink?: string(name='InstanceList'),
  operaUid?: string(name='OperaUid'),
  resourceType?: int32(name='ResourceType'),
  updateUser?: string(name='UpdateUser'),
}

model AddBusinessGroupResponseBody = {
  code?: int32(name='Code'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model AddBusinessGroupResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: AddBusinessGroupResponseBody(name='body'),
}

async function addBusinessGroupWithOptions(tmpReq: AddBusinessGroupRequest, runtime: Util.RuntimeOptions): AddBusinessGroupResponse {
  Util.validateModel(tmpReq);
  var request = new AddBusinessGroupShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.instanceList)) {
    request.instanceListShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.instanceList, 'InstanceList', 'json');
  }
  var query = {};
  if (!Util.isUnset(request.aliUid)) {
    query['AliUid'] = request.aliUid;
  }
  if (!Util.isUnset(request.businessGroupDesc)) {
    query['BusinessGroupDesc'] = request.businessGroupDesc;
  }
  if (!Util.isUnset(request.businessGroupName)) {
    query['BusinessGroupName'] = request.businessGroupName;
  }
  if (!Util.isUnset(request.createUser)) {
    query['CreateUser'] = request.createUser;
  }
  if (!Util.isUnset(request.instanceListShrink)) {
    query['InstanceList'] = request.instanceListShrink;
  }
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  if (!Util.isUnset(request.resourceType)) {
    query['ResourceType'] = request.resourceType;
  }
  if (!Util.isUnset(request.updateUser)) {
    query['UpdateUser'] = request.updateUser;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'AddBusinessGroup',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function addBusinessGroup(request: AddBusinessGroupRequest): AddBusinessGroupResponse {
  var runtime = new Util.RuntimeOptions{};
  return addBusinessGroupWithOptions(request, runtime);
}

model AddBusinessGroupOneRequest {
  businessGroupDesc?: string(name='BusinessGroupDesc'),
  businessGroupName?: string(name='BusinessGroupName'),
  operaUid?: string(name='OperaUid'),
}

model AddBusinessGroupOneResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model AddBusinessGroupOneResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: AddBusinessGroupOneResponseBody(name='body'),
}

async function addBusinessGroupOneWithOptions(request: AddBusinessGroupOneRequest, runtime: Util.RuntimeOptions): AddBusinessGroupOneResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  var body : map[string]any = {};
  if (!Util.isUnset(request.businessGroupDesc)) {
    body['BusinessGroupDesc'] = request.businessGroupDesc;
  }
  if (!Util.isUnset(request.businessGroupName)) {
    body['BusinessGroupName'] = request.businessGroupName;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'AddBusinessGroupOne',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function addBusinessGroupOne(request: AddBusinessGroupOneRequest): AddBusinessGroupOneResponse {
  var runtime = new Util.RuntimeOptions{};
  return addBusinessGroupOneWithOptions(request, runtime);
}

model AddScenarioRequest {
  alertSettingId?: long(name='AlertSettingId'),
  level?: long(name='Level'),
  name?: string(name='Name'),
  operaUid?: string(name='OperaUid'),
}

model AddScenarioResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  pageTotal?: long(name='PageTotal'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model AddScenarioResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: AddScenarioResponseBody(name='body'),
}

async function addScenarioWithOptions(request: AddScenarioRequest, runtime: Util.RuntimeOptions): AddScenarioResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.alertSettingId)) {
    query['AlertSettingId'] = request.alertSettingId;
  }
  if (!Util.isUnset(request.level)) {
    query['Level'] = request.level;
  }
  if (!Util.isUnset(request.name)) {
    query['Name'] = request.name;
  }
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'AddScenario',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function addScenario(request: AddScenarioRequest): AddScenarioResponse {
  var runtime = new Util.RuntimeOptions{};
  return addScenarioWithOptions(request, runtime);
}

model AddSceneListRequest {
  operaUid?: string(name='OperaUid'),
  sceneDescribe?: string(name='SceneDescribe'),
  sceneName?: string(name='SceneName'),
  scenePersonLiable?: string(name='ScenePersonLiable'),
  sceneType?: string(name='SceneType'),
  sceneVoJson?: string(name='SceneVoJson'),
  webhook?: string(name='Webhook'),
}

model AddSceneListResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model AddSceneListResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: AddSceneListResponseBody(name='body'),
}

async function addSceneListWithOptions(request: AddSceneListRequest, runtime: Util.RuntimeOptions): AddSceneListResponse {
  Util.validateModel(request);
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'AddSceneList',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function addSceneList(request: AddSceneListRequest): AddSceneListResponse {
  var runtime = new Util.RuntimeOptions{};
  return addSceneListWithOptions(request, runtime);
}

model AddScriptRequest {
  handleSuggestDesc?: string(name='HandleSuggestDesc'),
  metricName?: string(name='MetricName'),
  operaUid?: string(name='OperaUid'),
  productCode?: string(name='ProductCode'),
  rootCauseDesc?: string(name='RootCauseDesc'),
  rootCausesLog?: string(name='RootCausesLog'),
  sceneId?: string(name='SceneId'),
  script?: string(name='Script'),
  scriptDesc?: string(name='ScriptDesc'),
  scriptLanguage?: string(name='ScriptLanguage'),
  scriptName?: string(name='ScriptName'),
  scriptVersion?: string(name='ScriptVersion', example='0.1'),
  status?: int32(name='Status'),
  type?: int32(name='Type'),
}

model AddScriptResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model AddScriptResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: AddScriptResponseBody(name='body'),
}

async function addScriptWithOptions(request: AddScriptRequest, runtime: Util.RuntimeOptions): AddScriptResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.handleSuggestDesc)) {
    query['HandleSuggestDesc'] = request.handleSuggestDesc;
  }
  if (!Util.isUnset(request.metricName)) {
    query['MetricName'] = request.metricName;
  }
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  if (!Util.isUnset(request.productCode)) {
    query['ProductCode'] = request.productCode;
  }
  if (!Util.isUnset(request.rootCauseDesc)) {
    query['RootCauseDesc'] = request.rootCauseDesc;
  }
  if (!Util.isUnset(request.rootCausesLog)) {
    query['RootCausesLog'] = request.rootCausesLog;
  }
  if (!Util.isUnset(request.sceneId)) {
    query['SceneId'] = request.sceneId;
  }
  if (!Util.isUnset(request.script)) {
    query['Script'] = request.script;
  }
  if (!Util.isUnset(request.scriptDesc)) {
    query['ScriptDesc'] = request.scriptDesc;
  }
  if (!Util.isUnset(request.scriptLanguage)) {
    query['ScriptLanguage'] = request.scriptLanguage;
  }
  if (!Util.isUnset(request.scriptName)) {
    query['ScriptName'] = request.scriptName;
  }
  if (!Util.isUnset(request.scriptVersion)) {
    query['ScriptVersion'] = request.scriptVersion;
  }
  if (!Util.isUnset(request.status)) {
    query['Status'] = request.status;
  }
  if (!Util.isUnset(request.type)) {
    query['Type'] = request.type;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'AddScript',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function addScript(request: AddScriptRequest): AddScriptResponse {
  var runtime = new Util.RuntimeOptions{};
  return addScriptWithOptions(request, runtime);
}

model AddTagInfoRequest {
  operaUid?: string(name='OperaUid'),
  productId?: long(name='ProductId'),
  tagName?: string(name='TagName'),
}

model AddTagInfoResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model AddTagInfoResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: AddTagInfoResponseBody(name='body'),
}

async function addTagInfoWithOptions(request: AddTagInfoRequest, runtime: Util.RuntimeOptions): AddTagInfoResponse {
  Util.validateModel(request);
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'AddTagInfo',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function addTagInfo(request: AddTagInfoRequest): AddTagInfoResponse {
  var runtime = new Util.RuntimeOptions{};
  return addTagInfoWithOptions(request, runtime);
}

model AgainSubmitApplyPermissionRequest {
  switchFrontOperaUid?: string(name='SwitchFrontOperaUid'),
  type?: string(name='Type'),
  uid?: long(name='Uid'),
}

model AgainSubmitApplyPermissionResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model AgainSubmitApplyPermissionResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: AgainSubmitApplyPermissionResponseBody(name='body'),
}

async function againSubmitApplyPermissionWithOptions(request: AgainSubmitApplyPermissionRequest, runtime: Util.RuntimeOptions): AgainSubmitApplyPermissionResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.switchFrontOperaUid)) {
    query['SwitchFrontOperaUid'] = request.switchFrontOperaUid;
  }
  if (!Util.isUnset(request.type)) {
    query['Type'] = request.type;
  }
  if (!Util.isUnset(request.uid)) {
    query['Uid'] = request.uid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'AgainSubmitApplyPermission',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function againSubmitApplyPermission(request: AgainSubmitApplyPermissionRequest): AgainSubmitApplyPermissionResponse {
  var runtime = new Util.RuntimeOptions{};
  return againSubmitApplyPermissionWithOptions(request, runtime);
}

model ApplyAuthorizationRequest {
  switchFrontOperaUid?: string(name='SwitchFrontOperaUid'),
  uid?: long(name='Uid'),
}

model ApplyAuthorizationResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model ApplyAuthorizationResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: ApplyAuthorizationResponseBody(name='body'),
}

async function applyAuthorizationWithOptions(request: ApplyAuthorizationRequest, runtime: Util.RuntimeOptions): ApplyAuthorizationResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.switchFrontOperaUid)) {
    query['SwitchFrontOperaUid'] = request.switchFrontOperaUid;
  }
  if (!Util.isUnset(request.uid)) {
    query['Uid'] = request.uid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ApplyAuthorization',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function applyAuthorization(request: ApplyAuthorizationRequest): ApplyAuthorizationResponse {
  var runtime = new Util.RuntimeOptions{};
  return applyAuthorizationWithOptions(request, runtime);
}

model CheckDataSourceLinkConnectionRequest {
  dataSourceParams?: string(name='DataSourceParams'),
  dataSourceType?: int32(name='DataSourceType'),
  operaUid?: string(name='OperaUid'),
}

model CheckDataSourceLinkConnectionResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model CheckDataSourceLinkConnectionResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: CheckDataSourceLinkConnectionResponseBody(name='body'),
}

async function checkDataSourceLinkConnectionWithOptions(request: CheckDataSourceLinkConnectionRequest, runtime: Util.RuntimeOptions): CheckDataSourceLinkConnectionResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.dataSourceParams)) {
    query['DataSourceParams'] = request.dataSourceParams;
  }
  if (!Util.isUnset(request.dataSourceType)) {
    query['DataSourceType'] = request.dataSourceType;
  }
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'CheckDataSourceLinkConnection',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function checkDataSourceLinkConnection(request: CheckDataSourceLinkConnectionRequest): CheckDataSourceLinkConnectionResponse {
  var runtime = new Util.RuntimeOptions{};
  return checkDataSourceLinkConnectionWithOptions(request, runtime);
}

model CheckLogRequest {
  dataSourceId?: long(name='DataSourceId'),
  operaUid?: string(name='OperaUid'),
}

model CheckLogResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  pageTotal?: long(name='PageTotal'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model CheckLogResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: CheckLogResponseBody(name='body'),
}

async function checkLogWithOptions(request: CheckLogRequest, runtime: Util.RuntimeOptions): CheckLogResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.dataSourceId)) {
    query['DataSourceId'] = request.dataSourceId;
  }
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'CheckLog',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function checkLog(request: CheckLogRequest): CheckLogResponse {
  var runtime = new Util.RuntimeOptions{};
  return checkLogWithOptions(request, runtime);
}

model CloseEventRequest {
  closeDesc?: string(name='CloseDesc'),
  id?: string(name='Id'),
}

model CloseEventResponseBody = {
  code?: string(name='Code'),
  data?: boolean(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model CloseEventResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: CloseEventResponseBody(name='body'),
}

async function closeEventWithOptions(request: CloseEventRequest, runtime: Util.RuntimeOptions): CloseEventResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.closeDesc)) {
    query['CloseDesc'] = request.closeDesc;
  }
  if (!Util.isUnset(request.id)) {
    query['Id'] = request.id;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'CloseEvent',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function closeEvent(request: CloseEventRequest): CloseEventResponse {
  var runtime = new Util.RuntimeOptions{};
  return closeEventWithOptions(request, runtime);
}

model ConfirmAuthorizationRequest {
  permissionType?: int32(name='PermissionType'),
  switchFrontOperaUid?: string(name='SwitchFrontOperaUid'),
  type?: string(name='Type'),
  uid?: long(name='Uid'),
}

model ConfirmAuthorizationResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model ConfirmAuthorizationResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: ConfirmAuthorizationResponseBody(name='body'),
}

async function confirmAuthorizationWithOptions(request: ConfirmAuthorizationRequest, runtime: Util.RuntimeOptions): ConfirmAuthorizationResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.permissionType)) {
    query['PermissionType'] = request.permissionType;
  }
  if (!Util.isUnset(request.switchFrontOperaUid)) {
    query['SwitchFrontOperaUid'] = request.switchFrontOperaUid;
  }
  if (!Util.isUnset(request.type)) {
    query['Type'] = request.type;
  }
  if (!Util.isUnset(request.uid)) {
    query['Uid'] = request.uid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ConfirmAuthorization',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function confirmAuthorization(request: ConfirmAuthorizationRequest): ConfirmAuthorizationResponse {
  var runtime = new Util.RuntimeOptions{};
  return confirmAuthorizationWithOptions(request, runtime);
}

model CountLatestReportsRequest {
  logStore?: string(name='LogStore'),
  productCode?: string(name='ProductCode'),
  uid?: long(name='Uid'),
}

model CountLatestReportsResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model CountLatestReportsResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: CountLatestReportsResponseBody(name='body'),
}

async function countLatestReportsWithOptions(request: CountLatestReportsRequest, runtime: Util.RuntimeOptions): CountLatestReportsResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.logStore)) {
    query['LogStore'] = request.logStore;
  }
  if (!Util.isUnset(request.productCode)) {
    query['ProductCode'] = request.productCode;
  }
  if (!Util.isUnset(request.uid)) {
    query['Uid'] = request.uid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'CountLatestReports',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function countLatestReports(request: CountLatestReportsRequest): CountLatestReportsResponse {
  var runtime = new Util.RuntimeOptions{};
  return countLatestReportsWithOptions(request, runtime);
}

model CreateAlertContactRequest {
  email?: string(name='Email'),
  name?: string(name='Name'),
  operaUid?: string(name='OperaUid'),
  phone?: string(name='Phone'),
  webhook?: string(name='Webhook'),
}

model CreateAlertContactResponseBody = {
  code?: int32(name='Code'),
  data?: boolean(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model CreateAlertContactResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: CreateAlertContactResponseBody(name='body'),
}

async function createAlertContactWithOptions(request: CreateAlertContactRequest, runtime: Util.RuntimeOptions): CreateAlertContactResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.email)) {
    body['Email'] = request.email;
  }
  if (!Util.isUnset(request.name)) {
    body['Name'] = request.name;
  }
  if (!Util.isUnset(request.operaUid)) {
    body['OperaUid'] = request.operaUid;
  }
  if (!Util.isUnset(request.phone)) {
    body['Phone'] = request.phone;
  }
  if (!Util.isUnset(request.webhook)) {
    body['Webhook'] = request.webhook;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'CreateAlertContact',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function createAlertContact(request: CreateAlertContactRequest): CreateAlertContactResponse {
  var runtime = new Util.RuntimeOptions{};
  return createAlertContactWithOptions(request, runtime);
}

model CreateAlertContactGroupRequest {
  alertContactGroupJson?: string(name='AlertContactGroupJson'),
  contactIdsJson?: string(name='ContactIdsJson'),
  operaUid?: string(name='OperaUid'),
}

model CreateAlertContactGroupResponseBody = {
  code?: int32(name='Code'),
  data?: boolean(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model CreateAlertContactGroupResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: CreateAlertContactGroupResponseBody(name='body'),
}

async function createAlertContactGroupWithOptions(request: CreateAlertContactGroupRequest, runtime: Util.RuntimeOptions): CreateAlertContactGroupResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.alertContactGroupJson)) {
    body['AlertContactGroupJson'] = request.alertContactGroupJson;
  }
  if (!Util.isUnset(request.contactIdsJson)) {
    body['ContactIdsJson'] = request.contactIdsJson;
  }
  if (!Util.isUnset(request.operaUid)) {
    body['OperaUid'] = request.operaUid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'CreateAlertContactGroup',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function createAlertContactGroup(request: CreateAlertContactGroupRequest): CreateAlertContactGroupResponse {
  var runtime = new Util.RuntimeOptions{};
  return createAlertContactGroupWithOptions(request, runtime);
}

model CreateCommandRequest {
  commandContent?: string(name='CommandContent'),
  description?: string(name='Description'),
  name?: string(name='Name'),
  regionId?: string(name='RegionId'),
  type?: string(name='Type'),
  workingDir?: string(name='WorkingDir'),
  timeout?: long(name='timeout'),
}

model CreateCommandResponseBody = {
  requestId?: string(name='RequestId'),
}

model CreateCommandResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: CreateCommandResponseBody(name='body'),
}

async function createCommandWithOptions(request: CreateCommandRequest, runtime: Util.RuntimeOptions): CreateCommandResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.commandContent)) {
    query['CommandContent'] = request.commandContent;
  }
  if (!Util.isUnset(request.description)) {
    query['Description'] = request.description;
  }
  if (!Util.isUnset(request.name)) {
    query['Name'] = request.name;
  }
  if (!Util.isUnset(request.regionId)) {
    query['RegionId'] = request.regionId;
  }
  if (!Util.isUnset(request.type)) {
    query['Type'] = request.type;
  }
  if (!Util.isUnset(request.workingDir)) {
    query['WorkingDir'] = request.workingDir;
  }
  if (!Util.isUnset(request.timeout)) {
    query['timeout'] = request.timeout;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'CreateCommand',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function createCommand(request: CreateCommandRequest): CreateCommandResponse {
  var runtime = new Util.RuntimeOptions{};
  return createCommandWithOptions(request, runtime);
}

model CreateDumpRequest {
  eventId?: string(name='EventId'),
  instanceId?: string(name='InstanceId'),
}

model CreateDumpResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: boolean(name='Status'),
}

model CreateDumpResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: CreateDumpResponseBody(name='body'),
}

async function createDumpWithOptions(request: CreateDumpRequest, runtime: Util.RuntimeOptions): CreateDumpResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.eventId)) {
    query['EventId'] = request.eventId;
  }
  if (!Util.isUnset(request.instanceId)) {
    query['InstanceId'] = request.instanceId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'CreateDump',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function createDump(request: CreateDumpRequest): CreateDumpResponse {
  var runtime = new Util.RuntimeOptions{};
  return createDumpWithOptions(request, runtime);
}

model CreateInspectionRecordRequest {
  operaUid?: string(name='OperaUid'),
  productCode?: string(name='ProductCode'),
  resourceId?: string(name='ResourceId'),
}

model CreateInspectionRecordResponseBody = {
  code?: int32(name='Code'),
  data?: string(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model CreateInspectionRecordResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: CreateInspectionRecordResponseBody(name='body'),
}

async function createInspectionRecordWithOptions(request: CreateInspectionRecordRequest, runtime: Util.RuntimeOptions): CreateInspectionRecordResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.operaUid)) {
    body['OperaUid'] = request.operaUid;
  }
  if (!Util.isUnset(request.productCode)) {
    body['ProductCode'] = request.productCode;
  }
  if (!Util.isUnset(request.resourceId)) {
    body['ResourceId'] = request.resourceId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'CreateInspectionRecord',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function createInspectionRecord(request: CreateInspectionRecordRequest): CreateInspectionRecordResponse {
  var runtime = new Util.RuntimeOptions{};
  return createInspectionRecordWithOptions(request, runtime);
}

model CreateMessageRequest {
  eventId?: string(name='EventId'),
  instanceId?: string(name='InstanceId'),
}

model CreateMessageResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: boolean(name='Status'),
}

model CreateMessageResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: CreateMessageResponseBody(name='body'),
}

async function createMessageWithOptions(request: CreateMessageRequest, runtime: Util.RuntimeOptions): CreateMessageResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.eventId)) {
    query['EventId'] = request.eventId;
  }
  if (!Util.isUnset(request.instanceId)) {
    query['InstanceId'] = request.instanceId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'CreateMessage',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function createMessage(request: CreateMessageRequest): CreateMessageResponse {
  var runtime = new Util.RuntimeOptions{};
  return createMessageWithOptions(request, runtime);
}

model CreateSceneRequest {
  flowName?: string(name='FlowName'),
  metricListJson?: string(name='MetricListJson'),
  nodeListJson?: string(name='NodeListJson'),
  operaUid?: string(name='OperaUid'),
  sceneDesc?: string(name='SceneDesc'),
  sceneName?: string(name='SceneName'),
  sceneOwner?: string(name='SceneOwner'),
  sceneWebhook?: string(name='SceneWebhook'),
}

model CreateSceneResponseBody = {
  code?: int32(name='Code'),
  data?: string(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model CreateSceneResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: CreateSceneResponseBody(name='body'),
}

async function createSceneWithOptions(request: CreateSceneRequest, runtime: Util.RuntimeOptions): CreateSceneResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.flowName)) {
    body['FlowName'] = request.flowName;
  }
  if (!Util.isUnset(request.metricListJson)) {
    body['MetricListJson'] = request.metricListJson;
  }
  if (!Util.isUnset(request.nodeListJson)) {
    body['NodeListJson'] = request.nodeListJson;
  }
  if (!Util.isUnset(request.operaUid)) {
    body['OperaUid'] = request.operaUid;
  }
  if (!Util.isUnset(request.sceneDesc)) {
    body['SceneDesc'] = request.sceneDesc;
  }
  if (!Util.isUnset(request.sceneName)) {
    body['SceneName'] = request.sceneName;
  }
  if (!Util.isUnset(request.sceneOwner)) {
    body['SceneOwner'] = request.sceneOwner;
  }
  if (!Util.isUnset(request.sceneWebhook)) {
    body['SceneWebhook'] = request.sceneWebhook;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'CreateScene',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function createScene(request: CreateSceneRequest): CreateSceneResponse {
  var runtime = new Util.RuntimeOptions{};
  return createSceneWithOptions(request, runtime);
}

model CreateSceneModelRequest {
  fcFunctionName?: string(name='FcFunctionName'),
  fcHandler?: string(name='FcHandler'),
  fcInitializer?: string(name='FcInitializer'),
  fcRegionNo?: string(name='FcRegionNo'),
  fcServiceName?: string(name='FcServiceName'),
  modelDesc?: string(name='ModelDesc'),
  modelLanguage?: int32(name='ModelLanguage'),
  modelMemo?: string(name='ModelMemo'),
  modelName?: string(name='ModelName'),
  modelType?: int32(name='ModelType'),
  operaUid?: string(name='OperaUid'),
  rootCauseDesc?: string(name='RootCauseDesc'),
  rootCauseSolution?: string(name='RootCauseSolution'),
}

model CreateSceneModelResponseBody = {
  code?: int32(name='Code'),
  data?: string(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model CreateSceneModelResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: CreateSceneModelResponseBody(name='body'),
}

async function createSceneModelWithOptions(request: CreateSceneModelRequest, runtime: Util.RuntimeOptions): CreateSceneModelResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.fcFunctionName)) {
    body['FcFunctionName'] = request.fcFunctionName;
  }
  if (!Util.isUnset(request.fcHandler)) {
    body['FcHandler'] = request.fcHandler;
  }
  if (!Util.isUnset(request.fcInitializer)) {
    body['FcInitializer'] = request.fcInitializer;
  }
  if (!Util.isUnset(request.fcRegionNo)) {
    body['FcRegionNo'] = request.fcRegionNo;
  }
  if (!Util.isUnset(request.fcServiceName)) {
    body['FcServiceName'] = request.fcServiceName;
  }
  if (!Util.isUnset(request.modelDesc)) {
    body['ModelDesc'] = request.modelDesc;
  }
  if (!Util.isUnset(request.modelLanguage)) {
    body['ModelLanguage'] = request.modelLanguage;
  }
  if (!Util.isUnset(request.modelMemo)) {
    body['ModelMemo'] = request.modelMemo;
  }
  if (!Util.isUnset(request.modelName)) {
    body['ModelName'] = request.modelName;
  }
  if (!Util.isUnset(request.modelType)) {
    body['ModelType'] = request.modelType;
  }
  if (!Util.isUnset(request.operaUid)) {
    body['OperaUid'] = request.operaUid;
  }
  if (!Util.isUnset(request.rootCauseDesc)) {
    body['RootCauseDesc'] = request.rootCauseDesc;
  }
  if (!Util.isUnset(request.rootCauseSolution)) {
    body['RootCauseSolution'] = request.rootCauseSolution;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'CreateSceneModel',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function createSceneModel(request: CreateSceneModelRequest): CreateSceneModelResponse {
  var runtime = new Util.RuntimeOptions{};
  return createSceneModelWithOptions(request, runtime);
}

model CreateSceneModelApplyRequest {
  modelId?: long(name='ModelId'),
  operaUid?: string(name='OperaUid'),
}

model CreateSceneModelApplyResponseBody = {
  code?: int32(name='Code'),
  data?: string(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model CreateSceneModelApplyResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: CreateSceneModelApplyResponseBody(name='body'),
}

async function createSceneModelApplyWithOptions(request: CreateSceneModelApplyRequest, runtime: Util.RuntimeOptions): CreateSceneModelApplyResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.modelId)) {
    body['ModelId'] = request.modelId;
  }
  if (!Util.isUnset(request.operaUid)) {
    body['OperaUid'] = request.operaUid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'CreateSceneModelApply',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function createSceneModelApply(request: CreateSceneModelApplyRequest): CreateSceneModelApplyResponse {
  var runtime = new Util.RuntimeOptions{};
  return createSceneModelApplyWithOptions(request, runtime);
}

model DelBusinessGroupRequest {
  businessGroupId?: string(name='BusinessGroupId'),
}

model DelBusinessGroupResponseBody = {
  code?: int32(name='Code'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model DelBusinessGroupResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DelBusinessGroupResponseBody(name='body'),
}

async function delBusinessGroupWithOptions(request: DelBusinessGroupRequest, runtime: Util.RuntimeOptions): DelBusinessGroupResponse {
  Util.validateModel(request);
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DelBusinessGroup',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function delBusinessGroup(request: DelBusinessGroupRequest): DelBusinessGroupResponse {
  var runtime = new Util.RuntimeOptions{};
  return delBusinessGroupWithOptions(request, runtime);
}

model DeleteAlertContactRequest {
  contactIdListJson?: string(name='ContactIdListJson'),
  groupId?: long(name='GroupId'),
  operaUid?: string(name='OperaUid'),
}

model DeleteAlertContactResponseBody = {
  code?: int32(name='Code'),
  data?: boolean(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model DeleteAlertContactResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DeleteAlertContactResponseBody(name='body'),
}

async function deleteAlertContactWithOptions(request: DeleteAlertContactRequest, runtime: Util.RuntimeOptions): DeleteAlertContactResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  var body : map[string]any = {};
  if (!Util.isUnset(request.contactIdListJson)) {
    body['ContactIdListJson'] = request.contactIdListJson;
  }
  if (!Util.isUnset(request.groupId)) {
    body['GroupId'] = request.groupId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'DeleteAlertContact',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function deleteAlertContact(request: DeleteAlertContactRequest): DeleteAlertContactResponse {
  var runtime = new Util.RuntimeOptions{};
  return deleteAlertContactWithOptions(request, runtime);
}

model DeleteAlertContactFromGroupRequest {
  contactIdListJson?: string(name='ContactIdListJson'),
  groupId?: long(name='GroupId'),
  operaUid?: string(name='OperaUid'),
}

model DeleteAlertContactFromGroupResponseBody = {
  code?: int32(name='Code'),
  data?: boolean(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model DeleteAlertContactFromGroupResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DeleteAlertContactFromGroupResponseBody(name='body'),
}

async function deleteAlertContactFromGroupWithOptions(request: DeleteAlertContactFromGroupRequest, runtime: Util.RuntimeOptions): DeleteAlertContactFromGroupResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  var body : map[string]any = {};
  if (!Util.isUnset(request.contactIdListJson)) {
    body['ContactIdListJson'] = request.contactIdListJson;
  }
  if (!Util.isUnset(request.groupId)) {
    body['GroupId'] = request.groupId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'DeleteAlertContactFromGroup',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function deleteAlertContactFromGroup(request: DeleteAlertContactFromGroupRequest): DeleteAlertContactFromGroupResponse {
  var runtime = new Util.RuntimeOptions{};
  return deleteAlertContactFromGroupWithOptions(request, runtime);
}

model DeleteAlertContactGroupRequest {
  groupId?: long(name='GroupId'),
  operaUid?: string(name='OperaUid'),
}

model DeleteAlertContactGroupResponseBody = {
  code?: int32(name='Code'),
  data?: boolean(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model DeleteAlertContactGroupResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DeleteAlertContactGroupResponseBody(name='body'),
}

async function deleteAlertContactGroupWithOptions(request: DeleteAlertContactGroupRequest, runtime: Util.RuntimeOptions): DeleteAlertContactGroupResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  var body : map[string]any = {};
  if (!Util.isUnset(request.groupId)) {
    body['GroupId'] = request.groupId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'DeleteAlertContactGroup',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function deleteAlertContactGroup(request: DeleteAlertContactGroupRequest): DeleteAlertContactGroupResponse {
  var runtime = new Util.RuntimeOptions{};
  return deleteAlertContactGroupWithOptions(request, runtime);
}

model DeleteAlertSettingRequest {
  alertSettingId?: long(name='AlertSettingId'),
  operaUid?: string(name='OperaUid'),
}

model DeleteAlertSettingResponseBody = {
  code?: int32(name='Code'),
  data?: boolean(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model DeleteAlertSettingResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DeleteAlertSettingResponseBody(name='body'),
}

async function deleteAlertSettingWithOptions(request: DeleteAlertSettingRequest, runtime: Util.RuntimeOptions): DeleteAlertSettingResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  var body : map[string]any = {};
  if (!Util.isUnset(request.alertSettingId)) {
    body['AlertSettingId'] = request.alertSettingId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'DeleteAlertSetting',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function deleteAlertSetting(request: DeleteAlertSettingRequest): DeleteAlertSettingResponse {
  var runtime = new Util.RuntimeOptions{};
  return deleteAlertSettingWithOptions(request, runtime);
}

model DeleteAlertSettingListRequest {
  customerIdsJson?: string(name='CustomerIdsJson'),
  operaUid?: string(name='OperaUid'),
}

model DeleteAlertSettingListResponseBody = {
  code?: int32(name='Code'),
  data?: boolean(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model DeleteAlertSettingListResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DeleteAlertSettingListResponseBody(name='body'),
}

async function deleteAlertSettingListWithOptions(request: DeleteAlertSettingListRequest, runtime: Util.RuntimeOptions): DeleteAlertSettingListResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  var body : map[string]any = {};
  if (!Util.isUnset(request.customerIdsJson)) {
    body['CustomerIdsJson'] = request.customerIdsJson;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'DeleteAlertSettingList',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function deleteAlertSettingList(request: DeleteAlertSettingListRequest): DeleteAlertSettingListResponse {
  var runtime = new Util.RuntimeOptions{};
  return deleteAlertSettingListWithOptions(request, runtime);
}

model DeleteAlgorithmInfoRequest {
  id?: long(name='Id'),
  operaUid?: string(name='OperaUid'),
}

model DeleteAlgorithmInfoResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model DeleteAlgorithmInfoResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DeleteAlgorithmInfoResponseBody(name='body'),
}

async function deleteAlgorithmInfoWithOptions(request: DeleteAlgorithmInfoRequest, runtime: Util.RuntimeOptions): DeleteAlgorithmInfoResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.id)) {
    query['Id'] = request.id;
  }
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DeleteAlgorithmInfo',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function deleteAlgorithmInfo(request: DeleteAlgorithmInfoRequest): DeleteAlgorithmInfoResponse {
  var runtime = new Util.RuntimeOptions{};
  return deleteAlgorithmInfoWithOptions(request, runtime);
}

model DeleteBusinessGroupRequest {
  businessGroupId?: string(name='BusinessGroupId'),
  operaUid?: string(name='OperaUid'),
}

model DeleteBusinessGroupResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model DeleteBusinessGroupResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DeleteBusinessGroupResponseBody(name='body'),
}

async function deleteBusinessGroupWithOptions(request: DeleteBusinessGroupRequest, runtime: Util.RuntimeOptions): DeleteBusinessGroupResponse {
  Util.validateModel(request);
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DeleteBusinessGroup',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function deleteBusinessGroup(request: DeleteBusinessGroupRequest): DeleteBusinessGroupResponse {
  var runtime = new Util.RuntimeOptions{};
  return deleteBusinessGroupWithOptions(request, runtime);
}

model DeleteBusinessResourceTagRequest {
  businessGroupId?: string(name='BusinessGroupId'),
  operaUid?: string(name='OperaUid'),
  productId?: string(name='ProductId'),
  resources?: string(name='Resources'),
}

model DeleteBusinessResourceTagResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model DeleteBusinessResourceTagResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DeleteBusinessResourceTagResponseBody(name='body'),
}

async function deleteBusinessResourceTagWithOptions(request: DeleteBusinessResourceTagRequest, runtime: Util.RuntimeOptions): DeleteBusinessResourceTagResponse {
  Util.validateModel(request);
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DeleteBusinessResourceTag',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function deleteBusinessResourceTag(request: DeleteBusinessResourceTagRequest): DeleteBusinessResourceTagResponse {
  var runtime = new Util.RuntimeOptions{};
  return deleteBusinessResourceTagWithOptions(request, runtime);
}

model DeleteDataSourceConfigRequest {
  id?: long(name='Id'),
  operaUid?: string(name='OperaUid'),
}

model DeleteDataSourceConfigResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model DeleteDataSourceConfigResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DeleteDataSourceConfigResponseBody(name='body'),
}

async function deleteDataSourceConfigWithOptions(request: DeleteDataSourceConfigRequest, runtime: Util.RuntimeOptions): DeleteDataSourceConfigResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.id)) {
    query['Id'] = request.id;
  }
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DeleteDataSourceConfig',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function deleteDataSourceConfig(request: DeleteDataSourceConfigRequest): DeleteDataSourceConfigResponse {
  var runtime = new Util.RuntimeOptions{};
  return deleteDataSourceConfigWithOptions(request, runtime);
}

model DeleteGroupTopologyTagLogRequest {
  businessGroupId?: string(name='BusinessGroupId'),
  operaUid?: string(name='OperaUid'),
}

model DeleteGroupTopologyTagLogResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model DeleteGroupTopologyTagLogResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DeleteGroupTopologyTagLogResponseBody(name='body'),
}

async function deleteGroupTopologyTagLogWithOptions(request: DeleteGroupTopologyTagLogRequest, runtime: Util.RuntimeOptions): DeleteGroupTopologyTagLogResponse {
  Util.validateModel(request);
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DeleteGroupTopologyTagLog',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function deleteGroupTopologyTagLog(request: DeleteGroupTopologyTagLogRequest): DeleteGroupTopologyTagLogResponse {
  var runtime = new Util.RuntimeOptions{};
  return deleteGroupTopologyTagLogWithOptions(request, runtime);
}

model DeleteRealSceneInfoRequest {
  id?: string(name='Id'),
  operaUid?: string(name='OperaUid'),
}

model DeleteRealSceneInfoResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model DeleteRealSceneInfoResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DeleteRealSceneInfoResponseBody(name='body'),
}

async function deleteRealSceneInfoWithOptions(request: DeleteRealSceneInfoRequest, runtime: Util.RuntimeOptions): DeleteRealSceneInfoResponse {
  Util.validateModel(request);
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DeleteRealSceneInfo',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function deleteRealSceneInfo(request: DeleteRealSceneInfoRequest): DeleteRealSceneInfoResponse {
  var runtime = new Util.RuntimeOptions{};
  return deleteRealSceneInfoWithOptions(request, runtime);
}

model DeleteReportEmailConfigRequest {
  mailConfigId?: long(name='MailConfigId'),
  operaUid?: string(name='OperaUid'),
}

model DeleteReportEmailConfigResponseBody = {
  code?: int32(name='Code'),
  data?: boolean(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model DeleteReportEmailConfigResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DeleteReportEmailConfigResponseBody(name='body'),
}

async function deleteReportEmailConfigWithOptions(request: DeleteReportEmailConfigRequest, runtime: Util.RuntimeOptions): DeleteReportEmailConfigResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.mailConfigId)) {
    body['MailConfigId'] = request.mailConfigId;
  }
  if (!Util.isUnset(request.operaUid)) {
    body['OperaUid'] = request.operaUid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'DeleteReportEmailConfig',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function deleteReportEmailConfig(request: DeleteReportEmailConfigRequest): DeleteReportEmailConfigResponse {
  var runtime = new Util.RuntimeOptions{};
  return deleteReportEmailConfigWithOptions(request, runtime);
}

model DeleteResourceWhitelistRequest {
  inspectionWhitelistId?: long(name='InspectionWhitelistId'),
  operaUid?: string(name='OperaUid'),
}

model DeleteResourceWhitelistResponseBody = {
  code?: int32(name='Code'),
  data?: boolean(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model DeleteResourceWhitelistResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DeleteResourceWhitelistResponseBody(name='body'),
}

async function deleteResourceWhitelistWithOptions(request: DeleteResourceWhitelistRequest, runtime: Util.RuntimeOptions): DeleteResourceWhitelistResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.inspectionWhitelistId)) {
    body['InspectionWhitelistId'] = request.inspectionWhitelistId;
  }
  if (!Util.isUnset(request.operaUid)) {
    body['OperaUid'] = request.operaUid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'DeleteResourceWhitelist',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function deleteResourceWhitelist(request: DeleteResourceWhitelistRequest): DeleteResourceWhitelistResponse {
  var runtime = new Util.RuntimeOptions{};
  return deleteResourceWhitelistWithOptions(request, runtime);
}

model DeleteScenarioRequest {
  id?: string(name='Id'),
  operaUid?: string(name='OperaUid'),
}

model DeleteScenarioResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  pageTotal?: long(name='PageTotal'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model DeleteScenarioResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DeleteScenarioResponseBody(name='body'),
}

async function deleteScenarioWithOptions(request: DeleteScenarioRequest, runtime: Util.RuntimeOptions): DeleteScenarioResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.id)) {
    query['Id'] = request.id;
  }
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DeleteScenario',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function deleteScenario(request: DeleteScenarioRequest): DeleteScenarioResponse {
  var runtime = new Util.RuntimeOptions{};
  return deleteScenarioWithOptions(request, runtime);
}

model DeleteSceneRequest {
  operaUid?: string(name='OperaUid'),
  sceneId?: long(name='SceneId'),
}

model DeleteSceneResponseBody = {
  code?: int32(name='Code'),
  data?: string(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model DeleteSceneResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DeleteSceneResponseBody(name='body'),
}

async function deleteSceneWithOptions(request: DeleteSceneRequest, runtime: Util.RuntimeOptions): DeleteSceneResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.operaUid)) {
    body['OperaUid'] = request.operaUid;
  }
  if (!Util.isUnset(request.sceneId)) {
    body['SceneId'] = request.sceneId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'DeleteScene',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function deleteScene(request: DeleteSceneRequest): DeleteSceneResponse {
  var runtime = new Util.RuntimeOptions{};
  return deleteSceneWithOptions(request, runtime);
}

model DeleteSceneListRequest {
  id?: int32(name='Id'),
  operaUid?: string(name='OperaUid'),
}

model DeleteSceneListResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model DeleteSceneListResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DeleteSceneListResponseBody(name='body'),
}

async function deleteSceneListWithOptions(request: DeleteSceneListRequest, runtime: Util.RuntimeOptions): DeleteSceneListResponse {
  Util.validateModel(request);
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DeleteSceneList',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function deleteSceneList(request: DeleteSceneListRequest): DeleteSceneListResponse {
  var runtime = new Util.RuntimeOptions{};
  return deleteSceneListWithOptions(request, runtime);
}

model DeleteSceneModelRequest {
  modelId?: long(name='ModelId'),
  operaUid?: string(name='OperaUid'),
  sureDelete?: boolean(name='SureDelete'),
}

model DeleteSceneModelResponseBody = {
  code?: int32(name='Code'),
  data?: string(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model DeleteSceneModelResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DeleteSceneModelResponseBody(name='body'),
}

async function deleteSceneModelWithOptions(request: DeleteSceneModelRequest, runtime: Util.RuntimeOptions): DeleteSceneModelResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.modelId)) {
    body['ModelId'] = request.modelId;
  }
  if (!Util.isUnset(request.operaUid)) {
    body['OperaUid'] = request.operaUid;
  }
  if (!Util.isUnset(request.sureDelete)) {
    body['SureDelete'] = request.sureDelete;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'DeleteSceneModel',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function deleteSceneModel(request: DeleteSceneModelRequest): DeleteSceneModelResponse {
  var runtime = new Util.RuntimeOptions{};
  return deleteSceneModelWithOptions(request, runtime);
}

model DeleteTagInfoRequest {
  operaUid?: string(name='OperaUid'),
  tagId?: long(name='TagId'),
}

model DeleteTagInfoResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model DeleteTagInfoResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DeleteTagInfoResponseBody(name='body'),
}

async function deleteTagInfoWithOptions(request: DeleteTagInfoRequest, runtime: Util.RuntimeOptions): DeleteTagInfoResponse {
  Util.validateModel(request);
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DeleteTagInfo',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function deleteTagInfo(request: DeleteTagInfoRequest): DeleteTagInfoResponse {
  var runtime = new Util.RuntimeOptions{};
  return deleteTagInfoWithOptions(request, runtime);
}

model DescribeAccountAlertEventRequest {
  eventId?: string(name='EventId'),
  operaUid?: string(name='OperaUid'),
}

model DescribeAccountAlertEventResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model DescribeAccountAlertEventResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeAccountAlertEventResponseBody(name='body'),
}

async function describeAccountAlertEventWithOptions(request: DescribeAccountAlertEventRequest, runtime: Util.RuntimeOptions): DescribeAccountAlertEventResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.eventId)) {
    query['EventId'] = request.eventId;
  }
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeAccountAlertEvent',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeAccountAlertEvent(request: DescribeAccountAlertEventRequest): DescribeAccountAlertEventResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeAccountAlertEventWithOptions(request, runtime);
}

model DescribeAdvisorInspectionProductsRequest {
  operaUid?: string(name='OperaUid'),
}

model DescribeAdvisorInspectionProductsResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model DescribeAdvisorInspectionProductsResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeAdvisorInspectionProductsResponseBody(name='body'),
}

async function describeAdvisorInspectionProductsWithOptions(request: DescribeAdvisorInspectionProductsRequest, runtime: Util.RuntimeOptions): DescribeAdvisorInspectionProductsResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.operaUid)) {
    body['OperaUid'] = request.operaUid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'DescribeAdvisorInspectionProducts',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeAdvisorInspectionProducts(request: DescribeAdvisorInspectionProductsRequest): DescribeAdvisorInspectionProductsResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeAdvisorInspectionProductsWithOptions(request, runtime);
}

model DescribeAlertBusinessGroupWithAlertSettingIdRequest {
  alertSettingId?: long(name='AlertSettingId'),
}

model DescribeAlertBusinessGroupWithAlertSettingIdResponseBody = {
  code?: int32(name='Code'),
  data?: [ 
    {
      businessGroupId?: string(name='BusinessGroupId'),
      businessGroupName?: string(name='BusinessGroupName'),
    }
  ](name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model DescribeAlertBusinessGroupWithAlertSettingIdResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeAlertBusinessGroupWithAlertSettingIdResponseBody(name='body'),
}

async function describeAlertBusinessGroupWithAlertSettingIdWithOptions(request: DescribeAlertBusinessGroupWithAlertSettingIdRequest, runtime: Util.RuntimeOptions): DescribeAlertBusinessGroupWithAlertSettingIdResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.alertSettingId)) {
    body['AlertSettingId'] = request.alertSettingId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'DescribeAlertBusinessGroupWithAlertSettingId',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeAlertBusinessGroupWithAlertSettingId(request: DescribeAlertBusinessGroupWithAlertSettingIdRequest): DescribeAlertBusinessGroupWithAlertSettingIdResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeAlertBusinessGroupWithAlertSettingIdWithOptions(request, runtime);
}

model DescribeAlertContactRequest {
  currentPage?: int32(name='CurrentPage'),
  operaUid?: string(name='OperaUid'),
  pageSize?: int32(name='PageSize'),
  searchBy?: string(name='SearchBy'),
  searchLike?: string(name='SearchLike'),
}

model DescribeAlertContactResponseBody = {
  code?: int32(name='Code'),
  data?: [ 
    {
      email?: string(name='email'),
      gmtCreate?: long(name='gmtCreate'),
      gmtModified?: long(name='gmtModified'),
      groupNames?: string(name='groupNames'),
      id?: long(name='id'),
      name?: string(name='name'),
      phone?: string(name='phone'),
      uid?: long(name='uid'),
      webhook?: string(name='webhook'),
    }
  ](name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
  total?: long(name='Total'),
}

model DescribeAlertContactResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeAlertContactResponseBody(name='body'),
}

async function describeAlertContactWithOptions(request: DescribeAlertContactRequest, runtime: Util.RuntimeOptions): DescribeAlertContactResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.currentPage)) {
    body['CurrentPage'] = request.currentPage;
  }
  if (!Util.isUnset(request.operaUid)) {
    body['OperaUid'] = request.operaUid;
  }
  if (!Util.isUnset(request.pageSize)) {
    body['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchBy)) {
    body['SearchBy'] = request.searchBy;
  }
  if (!Util.isUnset(request.searchLike)) {
    body['SearchLike'] = request.searchLike;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'DescribeAlertContact',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeAlertContact(request: DescribeAlertContactRequest): DescribeAlertContactResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeAlertContactWithOptions(request, runtime);
}

model DescribeAlertContactGroupRequest {
  currentPage?: long(name='CurrentPage'),
  operaUid?: string(name='OperaUid'),
  pageSize?: long(name='PageSize'),
  searchLike?: string(name='SearchLike'),
}

model DescribeAlertContactGroupResponseBody = {
  code?: int32(name='Code'),
  data?: [ 
    {
      createTime?: string(name='createTime'),
      description?: string(name='description'),
      gmtCreate?: long(name='gmtCreate'),
      gmtModified?: long(name='gmtModified'),
      groupName?: string(name='groupName'),
      id?: long(name='id'),
      uid?: long(name='uid'),
      updateTime?: string(name='updateTime'),
    }
  ](name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
  total?: int32(name='Total'),
}

model DescribeAlertContactGroupResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeAlertContactGroupResponseBody(name='body'),
}

async function describeAlertContactGroupWithOptions(request: DescribeAlertContactGroupRequest, runtime: Util.RuntimeOptions): DescribeAlertContactGroupResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.currentPage)) {
    body['CurrentPage'] = request.currentPage;
  }
  if (!Util.isUnset(request.operaUid)) {
    body['OperaUid'] = request.operaUid;
  }
  if (!Util.isUnset(request.pageSize)) {
    body['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchLike)) {
    body['SearchLike'] = request.searchLike;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'DescribeAlertContactGroup',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeAlertContactGroup(request: DescribeAlertContactGroupRequest): DescribeAlertContactGroupResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeAlertContactGroupWithOptions(request, runtime);
}

model DescribeAlertContactWithAlertSettingIdRequest {
  alertSettingId?: long(name='AlertSettingId'),
  contactType?: long(name='ContactType'),
}

model DescribeAlertContactWithAlertSettingIdResponseBody = {
  code?: int32(name='Code'),
  data?: [ 
    {
      contactId?: long(name='contactId'),
      contactName?: string(name='contactName'),
      contactType?: long(name='contactType'),
    }
  ](name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model DescribeAlertContactWithAlertSettingIdResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeAlertContactWithAlertSettingIdResponseBody(name='body'),
}

async function describeAlertContactWithAlertSettingIdWithOptions(request: DescribeAlertContactWithAlertSettingIdRequest, runtime: Util.RuntimeOptions): DescribeAlertContactWithAlertSettingIdResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.alertSettingId)) {
    body['AlertSettingId'] = request.alertSettingId;
  }
  if (!Util.isUnset(request.contactType)) {
    body['ContactType'] = request.contactType;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'DescribeAlertContactWithAlertSettingId',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeAlertContactWithAlertSettingId(request: DescribeAlertContactWithAlertSettingIdRequest): DescribeAlertContactWithAlertSettingIdResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeAlertContactWithAlertSettingIdWithOptions(request, runtime);
}

model DescribeAlertContactWithGroupIdRequest {
  groupId?: long(name='GroupId'),
}

model DescribeAlertContactWithGroupIdResponseBody = {
  code?: int32(name='Code'),
  data?: [ 
    {
      email?: string(name='email'),
      gmtCreate?: long(name='gmtCreate'),
      gmtModified?: long(name='gmtModified'),
      id?: long(name='id'),
      name?: string(name='name'),
      phone?: string(name='phone'),
      uid?: long(name='uid'),
      webhook?: string(name='webhook'),
    }
  ](name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model DescribeAlertContactWithGroupIdResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeAlertContactWithGroupIdResponseBody(name='body'),
}

async function describeAlertContactWithGroupIdWithOptions(request: DescribeAlertContactWithGroupIdRequest, runtime: Util.RuntimeOptions): DescribeAlertContactWithGroupIdResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.groupId)) {
    body['GroupId'] = request.groupId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'DescribeAlertContactWithGroupId',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeAlertContactWithGroupId(request: DescribeAlertContactWithGroupIdRequest): DescribeAlertContactWithGroupIdResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeAlertContactWithGroupIdWithOptions(request, runtime);
}

model DescribeAlertDetailDataRequest {
  alertId?: long(name='AlertId'),
  operaUid?: string(name='OperaUid'),
}

model DescribeAlertDetailDataResponseBody = {
  code?: int32(name='Code'),
  data?: {
    alertName?: string(name='AlertName'),
    algorithm?: string(name='Algorithm'),
    beginTime?: string(name='BeginTime'),
    category?: string(name='Category'),
    countConvergence?: int32(name='CountConvergence'),
    endTime?: string(name='EndTime'),
    instanceId?: string(name='InstanceId'),
    instanceName?: string(name='InstanceName'),
    instanceRegionName?: string(name='InstanceRegionName'),
    metricExtend?: string(name='MetricExtend'),
    mttr?: string(name='Mttr'),
    serviceType?: string(name='ServiceType'),
    metricName?: string(name='metricName'),
    metricUnit?: string(name='metricUnit'),
    productCodeKey?: string(name='productCodeKey'),
  }(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model DescribeAlertDetailDataResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeAlertDetailDataResponseBody(name='body'),
}

async function describeAlertDetailDataWithOptions(request: DescribeAlertDetailDataRequest, runtime: Util.RuntimeOptions): DescribeAlertDetailDataResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.alertId)) {
    query['AlertId'] = request.alertId;
  }
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeAlertDetailData',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeAlertDetailData(request: DescribeAlertDetailDataRequest): DescribeAlertDetailDataResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeAlertDetailDataWithOptions(request, runtime);
}

model DescribeAlertDetailTrendDataRequest {
  alertId?: long(name='AlertId'),
  beginTime?: long(name='BeginTime'),
  endTime?: long(name='EndTime'),
  operaUid?: string(name='OperaUid'),
}

model DescribeAlertDetailTrendDataResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model DescribeAlertDetailTrendDataResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeAlertDetailTrendDataResponseBody(name='body'),
}

async function describeAlertDetailTrendDataWithOptions(request: DescribeAlertDetailTrendDataRequest, runtime: Util.RuntimeOptions): DescribeAlertDetailTrendDataResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.alertId)) {
    query['AlertId'] = request.alertId;
  }
  if (!Util.isUnset(request.beginTime)) {
    query['BeginTime'] = request.beginTime;
  }
  if (!Util.isUnset(request.endTime)) {
    query['EndTime'] = request.endTime;
  }
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeAlertDetailTrendData',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeAlertDetailTrendData(request: DescribeAlertDetailTrendDataRequest): DescribeAlertDetailTrendDataResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeAlertDetailTrendDataWithOptions(request, runtime);
}

model DescribeAlertEventRequest {
  eventId?: string(name='EventId'),
  operaUid?: string(name='OperaUid'),
}

model DescribeAlertEventResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model DescribeAlertEventResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeAlertEventResponseBody(name='body'),
}

async function describeAlertEventWithOptions(request: DescribeAlertEventRequest, runtime: Util.RuntimeOptions): DescribeAlertEventResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.eventId)) {
    query['EventId'] = request.eventId;
  }
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeAlertEvent',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeAlertEvent(request: DescribeAlertEventRequest): DescribeAlertEventResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeAlertEventWithOptions(request, runtime);
}

model DescribeAlertFinalDataListRequest {
  currentPage?: int32(name='CurrentPage'),
  endTime?: long(name='EndTime'),
  instanceId?: string(name='InstanceId'),
  metricName?: string(name='MetricName'),
  pageSize?: int32(name='PageSize'),
  productCode?: string(name='ProductCode'),
  startTime?: long(name='StartTime'),
  uid?: string(name='Uid'),
}

model DescribeAlertFinalDataListResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  pageTotal?: long(name='PageTotal'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model DescribeAlertFinalDataListResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeAlertFinalDataListResponseBody(name='body'),
}

async function describeAlertFinalDataListWithOptions(request: DescribeAlertFinalDataListRequest, runtime: Util.RuntimeOptions): DescribeAlertFinalDataListResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.currentPage)) {
    query['CurrentPage'] = request.currentPage;
  }
  if (!Util.isUnset(request.endTime)) {
    query['EndTime'] = request.endTime;
  }
  if (!Util.isUnset(request.instanceId)) {
    query['InstanceId'] = request.instanceId;
  }
  if (!Util.isUnset(request.metricName)) {
    query['MetricName'] = request.metricName;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.productCode)) {
    query['ProductCode'] = request.productCode;
  }
  if (!Util.isUnset(request.startTime)) {
    query['StartTime'] = request.startTime;
  }
  if (!Util.isUnset(request.uid)) {
    query['Uid'] = request.uid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeAlertFinalDataList',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeAlertFinalDataList(request: DescribeAlertFinalDataListRequest): DescribeAlertFinalDataListResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeAlertFinalDataListWithOptions(request, runtime);
}

model DescribeAlertResourceRequest {
  eventId?: string(name='EventId'),
  operaUid?: string(name='OperaUid'),
}

model DescribeAlertResourceResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model DescribeAlertResourceResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeAlertResourceResponseBody(name='body'),
}

async function describeAlertResourceWithOptions(request: DescribeAlertResourceRequest, runtime: Util.RuntimeOptions): DescribeAlertResourceResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.eventId)) {
    query['EventId'] = request.eventId;
  }
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeAlertResource',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeAlertResource(request: DescribeAlertResourceRequest): DescribeAlertResourceResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeAlertResourceWithOptions(request, runtime);
}

model DescribeAlertSettingRequest {
  currentPage?: long(name='CurrentPage'),
  customerName?: string(name='CustomerName'),
  operaUid?: string(name='OperaUid'),
  pageSize?: long(name='PageSize'),
  searchKeyword?: string(name='SearchKeyword'),
  settingStatus?: string(name='SettingStatus', example='1'),
  uid?: long(name='Uid'),
}

model DescribeAlertSettingResponseBody = {
  code?: int32(name='Code'),
  data?: [ 
    {
      alarmLevel?: string(name='AlarmLevel'),
      alertName?: string(name='AlertName'),
      alertSettingId?: long(name='AlertSettingId'),
      businessGroupIds?: string(name='BusinessGroupIds'),
      businessGroupNames?: string(name='BusinessGroupNames'),
      contactIds?: string(name='ContactIds'),
      contactNames?: string(name='ContactNames'),
      sendDingtalkNotice?: boolean(name='SendDingtalkNotice'),
      sendEmailNotice?: boolean(name='SendEmailNotice'),
      sendSmsNotice?: boolean(name='SendSmsNotice'),
      settingStatus?: long(name='SettingStatus'),
      stopDuration?: long(name='StopDuration'),
      totalBusinessResourceNumber?: long(name='TotalBusinessResourceNumber'),
    }
  ](name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
  total?: int32(name='Total'),
}

model DescribeAlertSettingResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeAlertSettingResponseBody(name='body'),
}

async function describeAlertSettingWithOptions(request: DescribeAlertSettingRequest, runtime: Util.RuntimeOptions): DescribeAlertSettingResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.currentPage)) {
    body['CurrentPage'] = request.currentPage;
  }
  if (!Util.isUnset(request.customerName)) {
    body['CustomerName'] = request.customerName;
  }
  if (!Util.isUnset(request.operaUid)) {
    body['OperaUid'] = request.operaUid;
  }
  if (!Util.isUnset(request.pageSize)) {
    body['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.searchKeyword)) {
    body['SearchKeyword'] = request.searchKeyword;
  }
  if (!Util.isUnset(request.settingStatus)) {
    body['SettingStatus'] = request.settingStatus;
  }
  if (!Util.isUnset(request.uid)) {
    body['Uid'] = request.uid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'DescribeAlertSetting',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeAlertSetting(request: DescribeAlertSettingRequest): DescribeAlertSettingResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeAlertSettingWithOptions(request, runtime);
}

model DescribeAlertSettingByIdRequest {
  alertSettingId?: long(name='AlertSettingId'),
}

model DescribeAlertSettingByIdResponseBody = {
  code?: int32(name='Code'),
  data?: {
    alarmLevel?: string(name='AlarmLevel'),
    alertBusinessSettingId?: long(name='AlertBusinessSettingId'),
    alertName?: string(name='AlertName'),
    dataCreateTime?: string(name='DataCreateTime'),
    dataCreateUser?: string(name='DataCreateUser'),
    dataModifyTime?: string(name='DataModifyTime'),
    dataModifyUser?: string(name='DataModifyUser'),
    sendDingtalkNotice?: boolean(name='SendDingtalkNotice'),
    sendEmailNotice?: boolean(name='SendEmailNotice'),
    sendSmsNotice?: boolean(name='SendSmsNotice'),
    settingStatus?: long(name='SettingStatus'),
    stopDuration?: long(name='StopDuration'),
    uid?: long(name='Uid'),
  }(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model DescribeAlertSettingByIdResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeAlertSettingByIdResponseBody(name='body'),
}

async function describeAlertSettingByIdWithOptions(request: DescribeAlertSettingByIdRequest, runtime: Util.RuntimeOptions): DescribeAlertSettingByIdResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.alertSettingId)) {
    body['AlertSettingId'] = request.alertSettingId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'DescribeAlertSettingById',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeAlertSettingById(request: DescribeAlertSettingByIdRequest): DescribeAlertSettingByIdResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeAlertSettingByIdWithOptions(request, runtime);
}

model DescribeAllAlertContactRequest {
  operaUid?: string(name='OperaUid'),
}

model DescribeAllAlertContactResponseBody = {
  code?: int32(name='Code'),
  data?: [ 
    {
      email?: string(name='email'),
      gmtCreate?: long(name='gmtCreate'),
      gmtModified?: long(name='gmtModified'),
      groupNames?: string(name='groupNames'),
      id?: long(name='id'),
      name?: string(name='name'),
      phone?: string(name='phone'),
      uid?: long(name='uid'),
      webhook?: string(name='webhook'),
    }
  ](name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model DescribeAllAlertContactResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeAllAlertContactResponseBody(name='body'),
}

async function describeAllAlertContactWithOptions(request: DescribeAllAlertContactRequest, runtime: Util.RuntimeOptions): DescribeAllAlertContactResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeAllAlertContact',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeAllAlertContact(request: DescribeAllAlertContactRequest): DescribeAllAlertContactResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeAllAlertContactWithOptions(request, runtime);
}

model DescribeAllAlertContactGroupRequest {
  operaUid?: string(name='OperaUid'),
}

model DescribeAllAlertContactGroupResponseBody = {
  code?: int32(name='Code'),
  data?: [ 
    {
      description?: string(name='description'),
      gmtCreate?: long(name='gmtCreate'),
      gmtModified?: long(name='gmtModified'),
      groupName?: string(name='groupName'),
      id?: long(name='id'),
      uid?: long(name='uid'),
    }
  ](name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model DescribeAllAlertContactGroupResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeAllAlertContactGroupResponseBody(name='body'),
}

async function describeAllAlertContactGroupWithOptions(request: DescribeAllAlertContactGroupRequest, runtime: Util.RuntimeOptions): DescribeAllAlertContactGroupResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.operaUid)) {
    body['OperaUid'] = request.operaUid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'DescribeAllAlertContactGroup',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeAllAlertContactGroup(request: DescribeAllAlertContactGroupRequest): DescribeAllAlertContactGroupResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeAllAlertContactGroupWithOptions(request, runtime);
}

model DescribeAllBusinessGroupInfoRequest {
  operaUid?: string(name='OperaUid'),
}

model DescribeAllBusinessGroupInfoResponseBody = {
  code?: int32(name='Code'),
  data?: [ 
    {
      businessGroupId?: string(name='BusinessGroupId'),
      businessGroupName?: string(name='BusinessGroupName'),
    }
  ](name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model DescribeAllBusinessGroupInfoResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeAllBusinessGroupInfoResponseBody(name='body'),
}

async function describeAllBusinessGroupInfoWithOptions(request: DescribeAllBusinessGroupInfoRequest, runtime: Util.RuntimeOptions): DescribeAllBusinessGroupInfoResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeAllBusinessGroupInfo',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeAllBusinessGroupInfo(request: DescribeAllBusinessGroupInfoRequest): DescribeAllBusinessGroupInfoResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeAllBusinessGroupInfoWithOptions(request, runtime);
}

model DescribeAllSceneModelRequest {
  operaUid?: string(name='OperaUid'),
}

model DescribeAllSceneModelResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model DescribeAllSceneModelResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeAllSceneModelResponseBody(name='body'),
}

async function describeAllSceneModelWithOptions(request: DescribeAllSceneModelRequest, runtime: Util.RuntimeOptions): DescribeAllSceneModelResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.operaUid)) {
    body['OperaUid'] = request.operaUid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'DescribeAllSceneModel',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeAllSceneModel(request: DescribeAllSceneModelRequest): DescribeAllSceneModelResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeAllSceneModelWithOptions(request, runtime);
}

model DescribeAnalysisDataListRequest {
  endTime?: long(name='EndTime'),
  instanceId?: string(name='InstanceId'),
  metricExtend?: string(name='MetricExtend'),
  metricName?: string(name='MetricName'),
  productCode?: string(name='ProductCode'),
  startTime?: long(name='StartTime'),
}

model DescribeAnalysisDataListResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: boolean(name='Status'),
}

model DescribeAnalysisDataListResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeAnalysisDataListResponseBody(name='body'),
}

async function describeAnalysisDataListWithOptions(request: DescribeAnalysisDataListRequest, runtime: Util.RuntimeOptions): DescribeAnalysisDataListResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.endTime)) {
    query['EndTime'] = request.endTime;
  }
  if (!Util.isUnset(request.instanceId)) {
    query['InstanceId'] = request.instanceId;
  }
  if (!Util.isUnset(request.metricExtend)) {
    query['MetricExtend'] = request.metricExtend;
  }
  if (!Util.isUnset(request.metricName)) {
    query['MetricName'] = request.metricName;
  }
  if (!Util.isUnset(request.productCode)) {
    query['ProductCode'] = request.productCode;
  }
  if (!Util.isUnset(request.startTime)) {
    query['StartTime'] = request.startTime;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeAnalysisDataList',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeAnalysisDataList(request: DescribeAnalysisDataListRequest): DescribeAnalysisDataListResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeAnalysisDataListWithOptions(request, runtime);
}

model DescribeBusinessAnalysisDataListRequest {
  apiPath?: string(name='ApiPath'),
  endTime?: long(name='EndTime'),
  resource?: string(name='Resource'),
  startTime?: long(name='StartTime'),
}

model DescribeBusinessAnalysisDataListResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: boolean(name='Status'),
}

model DescribeBusinessAnalysisDataListResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeBusinessAnalysisDataListResponseBody(name='body'),
}

async function describeBusinessAnalysisDataListWithOptions(request: DescribeBusinessAnalysisDataListRequest, runtime: Util.RuntimeOptions): DescribeBusinessAnalysisDataListResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.apiPath)) {
    query['ApiPath'] = request.apiPath;
  }
  if (!Util.isUnset(request.endTime)) {
    query['EndTime'] = request.endTime;
  }
  if (!Util.isUnset(request.resource)) {
    query['Resource'] = request.resource;
  }
  if (!Util.isUnset(request.startTime)) {
    query['StartTime'] = request.startTime;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeBusinessAnalysisDataList',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeBusinessAnalysisDataList(request: DescribeBusinessAnalysisDataListRequest): DescribeBusinessAnalysisDataListResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeBusinessAnalysisDataListWithOptions(request, runtime);
}

model DescribeDiagnoseRequest {
  product?: string(name='Product'),
}

model DescribeDiagnoseResponseBody = {
  code?: int32(name='Code'),
  diagnoseResult?: map[string]any(name='DiagnoseResult'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model DescribeDiagnoseResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeDiagnoseResponseBody(name='body'),
}

async function describeDiagnoseWithOptions(request: DescribeDiagnoseRequest, runtime: Util.RuntimeOptions): DescribeDiagnoseResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.product)) {
    query['Product'] = request.product;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeDiagnose',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeDiagnose(request: DescribeDiagnoseRequest): DescribeDiagnoseResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeDiagnoseWithOptions(request, runtime);
}

model DescribeDiagnoseResultRequest {
  checkId?: string(name='CheckId'),
}

model DescribeDiagnoseResultResponseBody = {
  code?: int32(name='Code'),
  diagnoseResult?: map[string]any(name='DiagnoseResult'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model DescribeDiagnoseResultResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeDiagnoseResultResponseBody(name='body'),
}

async function describeDiagnoseResultWithOptions(request: DescribeDiagnoseResultRequest, runtime: Util.RuntimeOptions): DescribeDiagnoseResultResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.checkId)) {
    query['CheckId'] = request.checkId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeDiagnoseResult',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeDiagnoseResult(request: DescribeDiagnoseResultRequest): DescribeDiagnoseResultResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeDiagnoseResultWithOptions(request, runtime);
}

model DescribeEventTopologyRequest {
  eventId?: string(name='EventId'),
  operaUid?: string(name='OperaUid'),
}

model DescribeEventTopologyResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model DescribeEventTopologyResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeEventTopologyResponseBody(name='body'),
}

async function describeEventTopologyWithOptions(request: DescribeEventTopologyRequest, runtime: Util.RuntimeOptions): DescribeEventTopologyResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.eventId)) {
    query['EventId'] = request.eventId;
  }
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeEventTopology',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeEventTopology(request: DescribeEventTopologyRequest): DescribeEventTopologyResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeEventTopologyWithOptions(request, runtime);
}

model DescribeEventTopologyDetailRequest {
  eventId?: string(name='EventId'),
  operaUid?: string(name='OperaUid'),
  tagId?: long(name='TagId'),
}

model DescribeEventTopologyDetailResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model DescribeEventTopologyDetailResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeEventTopologyDetailResponseBody(name='body'),
}

async function describeEventTopologyDetailWithOptions(request: DescribeEventTopologyDetailRequest, runtime: Util.RuntimeOptions): DescribeEventTopologyDetailResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.eventId)) {
    query['EventId'] = request.eventId;
  }
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  if (!Util.isUnset(request.tagId)) {
    query['TagId'] = request.tagId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeEventTopologyDetail',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeEventTopologyDetail(request: DescribeEventTopologyDetailRequest): DescribeEventTopologyDetailResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeEventTopologyDetailWithOptions(request, runtime);
}

model DescribeFcFunctionRequest {
  limit?: int32(name='Limit'),
  nextToken?: string(name='NextToken'),
  operaUid?: string(name='OperaUid'),
  prefix?: string(name='Prefix'),
  regionCode?: string(name='RegionCode'),
  serviceName?: string(name='ServiceName'),
}

model DescribeFcFunctionResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  message?: string(name='Message'),
  nextToken?: string(name='NextToken'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model DescribeFcFunctionResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeFcFunctionResponseBody(name='body'),
}

async function describeFcFunctionWithOptions(request: DescribeFcFunctionRequest, runtime: Util.RuntimeOptions): DescribeFcFunctionResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.limit)) {
    body['Limit'] = request.limit;
  }
  if (!Util.isUnset(request.nextToken)) {
    body['NextToken'] = request.nextToken;
  }
  if (!Util.isUnset(request.operaUid)) {
    body['OperaUid'] = request.operaUid;
  }
  if (!Util.isUnset(request.prefix)) {
    body['Prefix'] = request.prefix;
  }
  if (!Util.isUnset(request.regionCode)) {
    body['RegionCode'] = request.regionCode;
  }
  if (!Util.isUnset(request.serviceName)) {
    body['ServiceName'] = request.serviceName;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'DescribeFcFunction',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeFcFunction(request: DescribeFcFunctionRequest): DescribeFcFunctionResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeFcFunctionWithOptions(request, runtime);
}

model DescribeFcRegionRequest {
  operaUid?: string(name='OperaUid'),
}

model DescribeFcRegionResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model DescribeFcRegionResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeFcRegionResponseBody(name='body'),
}

async function describeFcRegionWithOptions(request: DescribeFcRegionRequest, runtime: Util.RuntimeOptions): DescribeFcRegionResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.operaUid)) {
    body['OperaUid'] = request.operaUid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'DescribeFcRegion',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeFcRegion(request: DescribeFcRegionRequest): DescribeFcRegionResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeFcRegionWithOptions(request, runtime);
}

model DescribeFcServiceRequest {
  limit?: int32(name='Limit'),
  nextToken?: string(name='NextToken'),
  operaUid?: string(name='OperaUid'),
  prefix?: string(name='Prefix'),
  regionCode?: string(name='RegionCode'),
}

model DescribeFcServiceResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  message?: string(name='Message'),
  nextToken?: string(name='NextToken'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model DescribeFcServiceResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeFcServiceResponseBody(name='body'),
}

async function describeFcServiceWithOptions(request: DescribeFcServiceRequest, runtime: Util.RuntimeOptions): DescribeFcServiceResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.limit)) {
    body['Limit'] = request.limit;
  }
  if (!Util.isUnset(request.nextToken)) {
    body['NextToken'] = request.nextToken;
  }
  if (!Util.isUnset(request.operaUid)) {
    body['OperaUid'] = request.operaUid;
  }
  if (!Util.isUnset(request.prefix)) {
    body['Prefix'] = request.prefix;
  }
  if (!Util.isUnset(request.regionCode)) {
    body['RegionCode'] = request.regionCode;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'DescribeFcService',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeFcService(request: DescribeFcServiceRequest): DescribeFcServiceResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeFcServiceWithOptions(request, runtime);
}

model DescribeHistoryRiskRequest {
  currentPage?: int32(name='CurrentPage'),
  lastFindTimeEnd?: string(name='LastFindTimeEnd'),
  lastFindTimeStart?: string(name='LastFindTimeStart'),
  operaUid?: string(name='OperaUid'),
  pageSize?: int32(name='PageSize'),
  productCode?: string(name='ProductCode'),
  severity?: int32(name='Severity'),
}

model DescribeHistoryRiskResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
  total?: long(name='Total'),
}

model DescribeHistoryRiskResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeHistoryRiskResponseBody(name='body'),
}

async function describeHistoryRiskWithOptions(request: DescribeHistoryRiskRequest, runtime: Util.RuntimeOptions): DescribeHistoryRiskResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.currentPage)) {
    body['CurrentPage'] = request.currentPage;
  }
  if (!Util.isUnset(request.lastFindTimeEnd)) {
    body['LastFindTimeEnd'] = request.lastFindTimeEnd;
  }
  if (!Util.isUnset(request.lastFindTimeStart)) {
    body['LastFindTimeStart'] = request.lastFindTimeStart;
  }
  if (!Util.isUnset(request.operaUid)) {
    body['OperaUid'] = request.operaUid;
  }
  if (!Util.isUnset(request.pageSize)) {
    body['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.productCode)) {
    body['ProductCode'] = request.productCode;
  }
  if (!Util.isUnset(request.severity)) {
    body['Severity'] = request.severity;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'DescribeHistoryRisk',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeHistoryRisk(request: DescribeHistoryRiskRequest): DescribeHistoryRiskResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeHistoryRiskWithOptions(request, runtime);
}

model DescribeInspectionProgressRequest {
  inspectionRecordId?: long(name='InspectionRecordId'),
  operaUid?: string(name='OperaUid'),
}

model DescribeInspectionProgressResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model DescribeInspectionProgressResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeInspectionProgressResponseBody(name='body'),
}

async function describeInspectionProgressWithOptions(request: DescribeInspectionProgressRequest, runtime: Util.RuntimeOptions): DescribeInspectionProgressResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.inspectionRecordId)) {
    body['InspectionRecordId'] = request.inspectionRecordId;
  }
  if (!Util.isUnset(request.operaUid)) {
    body['OperaUid'] = request.operaUid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'DescribeInspectionProgress',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeInspectionProgress(request: DescribeInspectionProgressRequest): DescribeInspectionProgressResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeInspectionProgressWithOptions(request, runtime);
}

model DescribeInspectionResourcesRequest {
  keyword?: string(name='Keyword'),
  operaUid?: string(name='OperaUid'),
  productCode?: string(name='ProductCode'),
}

model DescribeInspectionResourcesResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model DescribeInspectionResourcesResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeInspectionResourcesResponseBody(name='body'),
}

async function describeInspectionResourcesWithOptions(request: DescribeInspectionResourcesRequest, runtime: Util.RuntimeOptions): DescribeInspectionResourcesResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.keyword)) {
    body['Keyword'] = request.keyword;
  }
  if (!Util.isUnset(request.operaUid)) {
    body['OperaUid'] = request.operaUid;
  }
  if (!Util.isUnset(request.productCode)) {
    body['ProductCode'] = request.productCode;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'DescribeInspectionResources',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeInspectionResources(request: DescribeInspectionResourcesRequest): DescribeInspectionResourcesResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeInspectionResourcesWithOptions(request, runtime);
}

model DescribeInspectionResultRequest {
  continuousDays?: int32(name='ContinuousDays'),
  currentPage?: int32(name='CurrentPage'),
  operaUid?: string(name='OperaUid'),
  pageSize?: int32(name='PageSize'),
  riskCode?: string(name='RiskCode'),
  severity?: int32(name='Severity'),
}

model DescribeInspectionResultResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
  total?: long(name='Total'),
}

model DescribeInspectionResultResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeInspectionResultResponseBody(name='body'),
}

async function describeInspectionResultWithOptions(request: DescribeInspectionResultRequest, runtime: Util.RuntimeOptions): DescribeInspectionResultResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.continuousDays)) {
    body['ContinuousDays'] = request.continuousDays;
  }
  if (!Util.isUnset(request.currentPage)) {
    body['CurrentPage'] = request.currentPage;
  }
  if (!Util.isUnset(request.operaUid)) {
    body['OperaUid'] = request.operaUid;
  }
  if (!Util.isUnset(request.pageSize)) {
    body['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.riskCode)) {
    body['RiskCode'] = request.riskCode;
  }
  if (!Util.isUnset(request.severity)) {
    body['Severity'] = request.severity;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'DescribeInspectionResult',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeInspectionResult(request: DescribeInspectionResultRequest): DescribeInspectionResultResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeInspectionResultWithOptions(request, runtime);
}

model DescribeInspectionSettingsRequest {
  operaUid?: string(name='OperaUid'),
  productCode?: string(name='ProductCode'),
  productType?: int32(name='ProductType'),
  riskDesc?: string(name='RiskDesc'),
  riskEnableStatus?: int32(name='RiskEnableStatus'),
  riskName?: string(name='RiskName'),
  riskType?: int32(name='RiskType'),
}

model DescribeInspectionSettingsResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model DescribeInspectionSettingsResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeInspectionSettingsResponseBody(name='body'),
}

async function describeInspectionSettingsWithOptions(request: DescribeInspectionSettingsRequest, runtime: Util.RuntimeOptions): DescribeInspectionSettingsResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.operaUid)) {
    body['OperaUid'] = request.operaUid;
  }
  if (!Util.isUnset(request.productCode)) {
    body['ProductCode'] = request.productCode;
  }
  if (!Util.isUnset(request.productType)) {
    body['ProductType'] = request.productType;
  }
  if (!Util.isUnset(request.riskDesc)) {
    body['RiskDesc'] = request.riskDesc;
  }
  if (!Util.isUnset(request.riskEnableStatus)) {
    body['RiskEnableStatus'] = request.riskEnableStatus;
  }
  if (!Util.isUnset(request.riskName)) {
    body['RiskName'] = request.riskName;
  }
  if (!Util.isUnset(request.riskType)) {
    body['RiskType'] = request.riskType;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'DescribeInspectionSettings',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeInspectionSettings(request: DescribeInspectionSettingsRequest): DescribeInspectionSettingsResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeInspectionSettingsWithOptions(request, runtime);
}

model DescribeInspectionThresholdRequest {
  operaUid?: string(name='OperaUid'),
  riskCode?: string(name='RiskCode'),
}

model DescribeInspectionThresholdResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model DescribeInspectionThresholdResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeInspectionThresholdResponseBody(name='body'),
}

async function describeInspectionThresholdWithOptions(request: DescribeInspectionThresholdRequest, runtime: Util.RuntimeOptions): DescribeInspectionThresholdResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.operaUid)) {
    body['OperaUid'] = request.operaUid;
  }
  if (!Util.isUnset(request.riskCode)) {
    body['RiskCode'] = request.riskCode;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'DescribeInspectionThreshold',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeInspectionThreshold(request: DescribeInspectionThresholdRequest): DescribeInspectionThresholdResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeInspectionThresholdWithOptions(request, runtime);
}

model DescribeInspectionWhitelistsRequest {
  operaUid?: string(name='OperaUid'),
  productCode?: string(name='ProductCode'),
}

model DescribeInspectionWhitelistsResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model DescribeInspectionWhitelistsResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeInspectionWhitelistsResponseBody(name='body'),
}

async function describeInspectionWhitelistsWithOptions(request: DescribeInspectionWhitelistsRequest, runtime: Util.RuntimeOptions): DescribeInspectionWhitelistsResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.operaUid)) {
    body['OperaUid'] = request.operaUid;
  }
  if (!Util.isUnset(request.productCode)) {
    body['ProductCode'] = request.productCode;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'DescribeInspectionWhitelists',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeInspectionWhitelists(request: DescribeInspectionWhitelistsRequest): DescribeInspectionWhitelistsResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeInspectionWhitelistsWithOptions(request, runtime);
}

model DescribeInvocationResultsRequest {
  commandId?: string(name='CommandId'),
  instanceId?: string(name='InstanceId'),
  invokeId?: string(name='InvokeId'),
  regionId?: string(name='RegionId'),
}

model DescribeInvocationResultsResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: boolean(name='Status'),
}

model DescribeInvocationResultsResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeInvocationResultsResponseBody(name='body'),
}

async function describeInvocationResultsWithOptions(request: DescribeInvocationResultsRequest, runtime: Util.RuntimeOptions): DescribeInvocationResultsResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.commandId)) {
    query['CommandId'] = request.commandId;
  }
  if (!Util.isUnset(request.instanceId)) {
    query['InstanceId'] = request.instanceId;
  }
  if (!Util.isUnset(request.invokeId)) {
    query['InvokeId'] = request.invokeId;
  }
  if (!Util.isUnset(request.regionId)) {
    query['RegionId'] = request.regionId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeInvocationResults',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeInvocationResults(request: DescribeInvocationResultsRequest): DescribeInvocationResultsResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeInvocationResultsWithOptions(request, runtime);
}

model DescribeLastInspectionSummaryRequest {
  operaUid?: string(name='OperaUid'),
}

model DescribeLastInspectionSummaryResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model DescribeLastInspectionSummaryResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeLastInspectionSummaryResponseBody(name='body'),
}

async function describeLastInspectionSummaryWithOptions(request: DescribeLastInspectionSummaryRequest, runtime: Util.RuntimeOptions): DescribeLastInspectionSummaryResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.operaUid)) {
    body['OperaUid'] = request.operaUid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'DescribeLastInspectionSummary',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeLastInspectionSummary(request: DescribeLastInspectionSummaryRequest): DescribeLastInspectionSummaryResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeLastInspectionSummaryWithOptions(request, runtime);
}

model DescribeModelRelationScenesRequest {
  modelId?: long(name='ModelId'),
  operaUid?: string(name='OperaUid'),
}

model DescribeModelRelationScenesResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model DescribeModelRelationScenesResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeModelRelationScenesResponseBody(name='body'),
}

async function describeModelRelationScenesWithOptions(request: DescribeModelRelationScenesRequest, runtime: Util.RuntimeOptions): DescribeModelRelationScenesResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.modelId)) {
    body['ModelId'] = request.modelId;
  }
  if (!Util.isUnset(request.operaUid)) {
    body['OperaUid'] = request.operaUid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'DescribeModelRelationScenes',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeModelRelationScenes(request: DescribeModelRelationScenesRequest): DescribeModelRelationScenesResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeModelRelationScenesWithOptions(request, runtime);
}

model DescribeProductRiskPieRequest {
  operaUid?: string(name='OperaUid'),
}

model DescribeProductRiskPieResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model DescribeProductRiskPieResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeProductRiskPieResponseBody(name='body'),
}

async function describeProductRiskPieWithOptions(request: DescribeProductRiskPieRequest, runtime: Util.RuntimeOptions): DescribeProductRiskPieResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.operaUid)) {
    body['OperaUid'] = request.operaUid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'DescribeProductRiskPie',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeProductRiskPie(request: DescribeProductRiskPieRequest): DescribeProductRiskPieResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeProductRiskPieWithOptions(request, runtime);
}

model DescribeReportDataResponseBody = {
  code?: int32(name='Code'),
  data?: {
    heathScore?: long(name='HeathScore'),
    heathScoreTrendList?: [ long ](name='HeathScoreTrendList'),
    preUpdateTime?: string(name='PreUpdateTime'),
    riskCount?: long(name='RiskCount'),
    riskCountTrendList?: [ long ](name='RiskCountTrendList'),
  }(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model DescribeReportDataResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeReportDataResponseBody(name='body'),
}

async function describeReportDataWithOptions(runtime: Util.RuntimeOptions): DescribeReportDataResponse {
  var req = new OpenApi.OpenApiRequest{};
  var params = new OpenApi.Params{
    action = 'DescribeReportData',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeReportData(): DescribeReportDataResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeReportDataWithOptions(runtime);
}

model DescribeReportEmailConfigsRequest {
  operaUid?: string(name='OperaUid'),
}

model DescribeReportEmailConfigsResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model DescribeReportEmailConfigsResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeReportEmailConfigsResponseBody(name='body'),
}

async function describeReportEmailConfigsWithOptions(request: DescribeReportEmailConfigsRequest, runtime: Util.RuntimeOptions): DescribeReportEmailConfigsResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.operaUid)) {
    body['OperaUid'] = request.operaUid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'DescribeReportEmailConfigs',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeReportEmailConfigs(request: DescribeReportEmailConfigsRequest): DescribeReportEmailConfigsResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeReportEmailConfigsWithOptions(request, runtime);
}

model DescribeReportSubscriptionsRequest {
  operaUid?: string(name='OperaUid'),
}

model DescribeReportSubscriptionsResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model DescribeReportSubscriptionsResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeReportSubscriptionsResponseBody(name='body'),
}

async function describeReportSubscriptionsWithOptions(request: DescribeReportSubscriptionsRequest, runtime: Util.RuntimeOptions): DescribeReportSubscriptionsResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.operaUid)) {
    body['OperaUid'] = request.operaUid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'DescribeReportSubscriptions',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeReportSubscriptions(request: DescribeReportSubscriptionsRequest): DescribeReportSubscriptionsResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeReportSubscriptionsWithOptions(request, runtime);
}

model DescribeResourceMetricRequest {
  eventId?: string(name='EventId'),
  firstLoad?: int32(name='FirstLoad'),
  instanceId?: string(name='InstanceId'),
  operaUid?: string(name='OperaUid'),
  productCode?: string(name='ProductCode'),
}

model DescribeResourceMetricResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model DescribeResourceMetricResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeResourceMetricResponseBody(name='body'),
}

async function describeResourceMetricWithOptions(request: DescribeResourceMetricRequest, runtime: Util.RuntimeOptions): DescribeResourceMetricResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.eventId)) {
    query['EventId'] = request.eventId;
  }
  if (!Util.isUnset(request.firstLoad)) {
    query['FirstLoad'] = request.firstLoad;
  }
  if (!Util.isUnset(request.instanceId)) {
    query['InstanceId'] = request.instanceId;
  }
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  if (!Util.isUnset(request.productCode)) {
    query['ProductCode'] = request.productCode;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeResourceMetric',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeResourceMetric(request: DescribeResourceMetricRequest): DescribeResourceMetricResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeResourceMetricWithOptions(request, runtime);
}

model DescribeRiskRequest {
  endTime?: long(name='EndTime'),
  startTime?: long(name='StartTime'),
  types?: string(name='Types'),
  uid?: long(name='Uid'),
}

model DescribeRiskResponseBody = {
  code?: string(name='Code'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  riskAssessment?: map[string]any(name='RiskAssessment'),
  status?: string(name='Status'),
}

model DescribeRiskResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeRiskResponseBody(name='body'),
}

async function describeRiskWithOptions(request: DescribeRiskRequest, runtime: Util.RuntimeOptions): DescribeRiskResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.endTime)) {
    query['EndTime'] = request.endTime;
  }
  if (!Util.isUnset(request.startTime)) {
    query['StartTime'] = request.startTime;
  }
  if (!Util.isUnset(request.types)) {
    query['Types'] = request.types;
  }
  if (!Util.isUnset(request.uid)) {
    query['Uid'] = request.uid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeRisk',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeRisk(request: DescribeRiskRequest): DescribeRiskResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeRiskWithOptions(request, runtime);
}

model DescribeRiskConfigRequest {
  operaUid?: string(name='OperaUid'),
}

model DescribeRiskConfigResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model DescribeRiskConfigResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeRiskConfigResponseBody(name='body'),
}

async function describeRiskConfigWithOptions(request: DescribeRiskConfigRequest, runtime: Util.RuntimeOptions): DescribeRiskConfigResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.operaUid)) {
    body['OperaUid'] = request.operaUid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'DescribeRiskConfig',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeRiskConfig(request: DescribeRiskConfigRequest): DescribeRiskConfigResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeRiskConfigWithOptions(request, runtime);
}

model DescribeRiskEventDetailsRequest {
  pageNumber?: int32(name='PageNumber'),
  pageSize?: int32(name='PageSize'),
}

model DescribeRiskEventDetailsResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  message?: string(name='Message'),
  pageTotal?: long(name='PageTotal'),
  requestId?: string(name='RequestId'),
  status?: boolean(name='Status'),
}

model DescribeRiskEventDetailsResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeRiskEventDetailsResponseBody(name='body'),
}

async function describeRiskEventDetailsWithOptions(request: DescribeRiskEventDetailsRequest, runtime: Util.RuntimeOptions): DescribeRiskEventDetailsResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.pageNumber)) {
    query['PageNumber'] = request.pageNumber;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeRiskEventDetails',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeRiskEventDetails(request: DescribeRiskEventDetailsRequest): DescribeRiskEventDetailsResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeRiskEventDetailsWithOptions(request, runtime);
}

model DescribeRiskEventListRequest {
  pageNumber?: int32(name='PageNumber'),
  pageSize?: int32(name='PageSize'),
}

model DescribeRiskEventListResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  message?: string(name='Message'),
  pageTotal?: long(name='PageTotal'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model DescribeRiskEventListResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeRiskEventListResponseBody(name='body'),
}

async function describeRiskEventListWithOptions(request: DescribeRiskEventListRequest, runtime: Util.RuntimeOptions): DescribeRiskEventListResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.pageNumber)) {
    query['PageNumber'] = request.pageNumber;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeRiskEventList',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeRiskEventList(request: DescribeRiskEventListRequest): DescribeRiskEventListResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeRiskEventListWithOptions(request, runtime);
}

model DescribeRiskEventTopologyRequest {
  eventId?: long(name='EventId'),
  operaUid?: string(name='OperaUid'),
}

model DescribeRiskEventTopologyResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model DescribeRiskEventTopologyResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeRiskEventTopologyResponseBody(name='body'),
}

async function describeRiskEventTopologyWithOptions(request: DescribeRiskEventTopologyRequest, runtime: Util.RuntimeOptions): DescribeRiskEventTopologyResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.eventId)) {
    query['EventId'] = request.eventId;
  }
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeRiskEventTopology',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeRiskEventTopology(request: DescribeRiskEventTopologyRequest): DescribeRiskEventTopologyResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeRiskEventTopologyWithOptions(request, runtime);
}

model DescribeRiskResultSeveritySummaryRequest {
  continuousDays?: int32(name='ContinuousDays'),
  operaUid?: string(name='OperaUid'),
  productCode?: string(name='ProductCode'),
}

model DescribeRiskResultSeveritySummaryResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model DescribeRiskResultSeveritySummaryResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeRiskResultSeveritySummaryResponseBody(name='body'),
}

async function describeRiskResultSeveritySummaryWithOptions(request: DescribeRiskResultSeveritySummaryRequest, runtime: Util.RuntimeOptions): DescribeRiskResultSeveritySummaryResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.continuousDays)) {
    body['ContinuousDays'] = request.continuousDays;
  }
  if (!Util.isUnset(request.operaUid)) {
    body['OperaUid'] = request.operaUid;
  }
  if (!Util.isUnset(request.productCode)) {
    body['ProductCode'] = request.productCode;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'DescribeRiskResultSeveritySummary',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeRiskResultSeveritySummary(request: DescribeRiskResultSeveritySummaryRequest): DescribeRiskResultSeveritySummaryResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeRiskResultSeveritySummaryWithOptions(request, runtime);
}

model DescribeRiskResultStatisticalRequest {
  continuousDays?: int32(name='ContinuousDays'),
  operaUid?: string(name='OperaUid'),
  productCode?: string(name='ProductCode'),
}

model DescribeRiskResultStatisticalResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model DescribeRiskResultStatisticalResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeRiskResultStatisticalResponseBody(name='body'),
}

async function describeRiskResultStatisticalWithOptions(request: DescribeRiskResultStatisticalRequest, runtime: Util.RuntimeOptions): DescribeRiskResultStatisticalResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.continuousDays)) {
    body['ContinuousDays'] = request.continuousDays;
  }
  if (!Util.isUnset(request.operaUid)) {
    body['OperaUid'] = request.operaUid;
  }
  if (!Util.isUnset(request.productCode)) {
    body['ProductCode'] = request.productCode;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'DescribeRiskResultStatistical',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeRiskResultStatistical(request: DescribeRiskResultStatisticalRequest): DescribeRiskResultStatisticalResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeRiskResultStatisticalWithOptions(request, runtime);
}

model DescribeSceneDetailRequest {
  operaUid?: string(name='OperaUid'),
  sceneId?: long(name='SceneId'),
}

model DescribeSceneDetailResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model DescribeSceneDetailResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeSceneDetailResponseBody(name='body'),
}

async function describeSceneDetailWithOptions(request: DescribeSceneDetailRequest, runtime: Util.RuntimeOptions): DescribeSceneDetailResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.operaUid)) {
    body['OperaUid'] = request.operaUid;
  }
  if (!Util.isUnset(request.sceneId)) {
    body['SceneId'] = request.sceneId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'DescribeSceneDetail',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeSceneDetail(request: DescribeSceneDetailRequest): DescribeSceneDetailResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeSceneDetailWithOptions(request, runtime);
}

model DescribeSceneModelByTypeRequest {
  modelType?: int32(name='ModelType'),
  operaUid?: string(name='OperaUid'),
}

model DescribeSceneModelByTypeResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model DescribeSceneModelByTypeResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeSceneModelByTypeResponseBody(name='body'),
}

async function describeSceneModelByTypeWithOptions(request: DescribeSceneModelByTypeRequest, runtime: Util.RuntimeOptions): DescribeSceneModelByTypeResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.modelType)) {
    body['ModelType'] = request.modelType;
  }
  if (!Util.isUnset(request.operaUid)) {
    body['OperaUid'] = request.operaUid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'DescribeSceneModelByType',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeSceneModelByType(request: DescribeSceneModelByTypeRequest): DescribeSceneModelByTypeResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeSceneModelByTypeWithOptions(request, runtime);
}

model DescribeSceneModelDetailRequest {
  modelId?: long(name='ModelId'),
  operaUid?: string(name='OperaUid'),
}

model DescribeSceneModelDetailResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model DescribeSceneModelDetailResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeSceneModelDetailResponseBody(name='body'),
}

async function describeSceneModelDetailWithOptions(request: DescribeSceneModelDetailRequest, runtime: Util.RuntimeOptions): DescribeSceneModelDetailResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.modelId)) {
    body['ModelId'] = request.modelId;
  }
  if (!Util.isUnset(request.operaUid)) {
    body['OperaUid'] = request.operaUid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'DescribeSceneModelDetail',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeSceneModelDetail(request: DescribeSceneModelDetailRequest): DescribeSceneModelDetailResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeSceneModelDetailWithOptions(request, runtime);
}

model DescribeSceneModelVersionHistoryRequest {
  modelId?: long(name='ModelId'),
  operaUid?: string(name='OperaUid'),
}

model DescribeSceneModelVersionHistoryResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model DescribeSceneModelVersionHistoryResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeSceneModelVersionHistoryResponseBody(name='body'),
}

async function describeSceneModelVersionHistoryWithOptions(request: DescribeSceneModelVersionHistoryRequest, runtime: Util.RuntimeOptions): DescribeSceneModelVersionHistoryResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.modelId)) {
    body['ModelId'] = request.modelId;
  }
  if (!Util.isUnset(request.operaUid)) {
    body['OperaUid'] = request.operaUid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'DescribeSceneModelVersionHistory',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeSceneModelVersionHistory(request: DescribeSceneModelVersionHistoryRequest): DescribeSceneModelVersionHistoryResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeSceneModelVersionHistoryWithOptions(request, runtime);
}

model DescribeSceneModelsRequest {
  applyStatus?: int32(name='ApplyStatus'),
  currentPage?: int32(name='CurrentPage'),
  modelName?: string(name='ModelName'),
  modelType?: int32(name='ModelType'),
  operaUid?: string(name='OperaUid'),
  pageSize?: int32(name='PageSize'),
}

model DescribeSceneModelsResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
  total?: long(name='Total'),
}

model DescribeSceneModelsResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeSceneModelsResponseBody(name='body'),
}

async function describeSceneModelsWithOptions(request: DescribeSceneModelsRequest, runtime: Util.RuntimeOptions): DescribeSceneModelsResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.applyStatus)) {
    body['ApplyStatus'] = request.applyStatus;
  }
  if (!Util.isUnset(request.currentPage)) {
    body['CurrentPage'] = request.currentPage;
  }
  if (!Util.isUnset(request.modelName)) {
    body['ModelName'] = request.modelName;
  }
  if (!Util.isUnset(request.modelType)) {
    body['ModelType'] = request.modelType;
  }
  if (!Util.isUnset(request.operaUid)) {
    body['OperaUid'] = request.operaUid;
  }
  if (!Util.isUnset(request.pageSize)) {
    body['PageSize'] = request.pageSize;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'DescribeSceneModels',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeSceneModels(request: DescribeSceneModelsRequest): DescribeSceneModelsResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeSceneModelsWithOptions(request, runtime);
}

model DescribeSceneSystemModelRequest {
  currentPage?: int32(name='CurrentPage'),
  modelName?: string(name='ModelName'),
  modelStatus?: int32(name='ModelStatus'),
  modelType?: int32(name='ModelType'),
  operaUid?: string(name='OperaUid'),
  pageSize?: int32(name='PageSize'),
  typeId?: long(name='TypeId'),
}

model DescribeSceneSystemModelResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
  total?: long(name='Total'),
}

model DescribeSceneSystemModelResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeSceneSystemModelResponseBody(name='body'),
}

async function describeSceneSystemModelWithOptions(request: DescribeSceneSystemModelRequest, runtime: Util.RuntimeOptions): DescribeSceneSystemModelResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.currentPage)) {
    body['CurrentPage'] = request.currentPage;
  }
  if (!Util.isUnset(request.modelName)) {
    body['ModelName'] = request.modelName;
  }
  if (!Util.isUnset(request.modelStatus)) {
    body['ModelStatus'] = request.modelStatus;
  }
  if (!Util.isUnset(request.modelType)) {
    body['ModelType'] = request.modelType;
  }
  if (!Util.isUnset(request.operaUid)) {
    body['OperaUid'] = request.operaUid;
  }
  if (!Util.isUnset(request.pageSize)) {
    body['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.typeId)) {
    body['TypeId'] = request.typeId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'DescribeSceneSystemModel',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeSceneSystemModel(request: DescribeSceneSystemModelRequest): DescribeSceneSystemModelResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeSceneSystemModelWithOptions(request, runtime);
}

model DescribeScenesRequest {
  currentPage?: int32(name='CurrentPage'),
  flowName?: string(name='FlowName'),
  modelId?: long(name='ModelId'),
  operaUid?: string(name='OperaUid'),
  pageSize?: int32(name='PageSize'),
  sceneName?: string(name='SceneName'),
  sceneStatus?: int32(name='SceneStatus'),
}

model DescribeScenesResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
  total?: long(name='Total'),
}

model DescribeScenesResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeScenesResponseBody(name='body'),
}

async function describeScenesWithOptions(request: DescribeScenesRequest, runtime: Util.RuntimeOptions): DescribeScenesResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.currentPage)) {
    body['CurrentPage'] = request.currentPage;
  }
  if (!Util.isUnset(request.flowName)) {
    body['FlowName'] = request.flowName;
  }
  if (!Util.isUnset(request.modelId)) {
    body['ModelId'] = request.modelId;
  }
  if (!Util.isUnset(request.operaUid)) {
    body['OperaUid'] = request.operaUid;
  }
  if (!Util.isUnset(request.pageSize)) {
    body['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.sceneName)) {
    body['SceneName'] = request.sceneName;
  }
  if (!Util.isUnset(request.sceneStatus)) {
    body['SceneStatus'] = request.sceneStatus;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'DescribeScenes',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeScenes(request: DescribeScenesRequest): DescribeScenesResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeScenesWithOptions(request, runtime);
}

model DescribeStatisticalDataByProductRequest {
  operaUid?: string(name='OperaUid'),
}

model DescribeStatisticalDataByProductResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model DescribeStatisticalDataByProductResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeStatisticalDataByProductResponseBody(name='body'),
}

async function describeStatisticalDataByProductWithOptions(request: DescribeStatisticalDataByProductRequest, runtime: Util.RuntimeOptions): DescribeStatisticalDataByProductResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.operaUid)) {
    body['OperaUid'] = request.operaUid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'DescribeStatisticalDataByProduct',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeStatisticalDataByProduct(request: DescribeStatisticalDataByProductRequest): DescribeStatisticalDataByProductResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeStatisticalDataByProductWithOptions(request, runtime);
}

model DescribeStatisticalDataByRiskCodeRequest {
  operaUid?: string(name='OperaUid'),
}

model DescribeStatisticalDataByRiskCodeResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model DescribeStatisticalDataByRiskCodeResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeStatisticalDataByRiskCodeResponseBody(name='body'),
}

async function describeStatisticalDataByRiskCodeWithOptions(request: DescribeStatisticalDataByRiskCodeRequest, runtime: Util.RuntimeOptions): DescribeStatisticalDataByRiskCodeResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.operaUid)) {
    body['OperaUid'] = request.operaUid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'DescribeStatisticalDataByRiskCode',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeStatisticalDataByRiskCode(request: DescribeStatisticalDataByRiskCodeRequest): DescribeStatisticalDataByRiskCodeResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeStatisticalDataByRiskCodeWithOptions(request, runtime);
}

model DescribeWhitelistResourcesRequest {
  keyword?: string(name='Keyword'),
  operaUid?: string(name='OperaUid'),
  productCode?: string(name='ProductCode'),
}

model DescribeWhitelistResourcesResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model DescribeWhitelistResourcesResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeWhitelistResourcesResponseBody(name='body'),
}

async function describeWhitelistResourcesWithOptions(request: DescribeWhitelistResourcesRequest, runtime: Util.RuntimeOptions): DescribeWhitelistResourcesResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.keyword)) {
    body['Keyword'] = request.keyword;
  }
  if (!Util.isUnset(request.operaUid)) {
    body['OperaUid'] = request.operaUid;
  }
  if (!Util.isUnset(request.productCode)) {
    body['ProductCode'] = request.productCode;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'DescribeWhitelistResources',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeWhitelistResources(request: DescribeWhitelistResourcesRequest): DescribeWhitelistResourcesResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeWhitelistResourcesWithOptions(request, runtime);
}

model EndScriptListRequest {
  id?: string(name='Id'),
  operaUid?: string(name='OperaUid'),
}

model EndScriptListResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model EndScriptListResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: EndScriptListResponseBody(name='body'),
}

async function endScriptListWithOptions(request: EndScriptListRequest, runtime: Util.RuntimeOptions): EndScriptListResponse {
  Util.validateModel(request);
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'EndScriptList',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function endScriptList(request: EndScriptListRequest): EndScriptListResponse {
  var runtime = new Util.RuntimeOptions{};
  return endScriptListWithOptions(request, runtime);
}

model FeedbackAlertAlgorithmRequest {
  alertId?: long(name='AlertId'),
  algorithmAccurateDescribe?: string(name='AlgorithmAccurateDescribe'),
  algorithmAccurateState?: int32(name='AlgorithmAccurateState'),
  feedbackType?: int32(name='FeedbackType'),
  operaUid?: string(name='OperaUid'),
}

model FeedbackAlertAlgorithmResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model FeedbackAlertAlgorithmResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: FeedbackAlertAlgorithmResponseBody(name='body'),
}

async function feedbackAlertAlgorithmWithOptions(request: FeedbackAlertAlgorithmRequest, runtime: Util.RuntimeOptions): FeedbackAlertAlgorithmResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.alertId)) {
    query['AlertId'] = request.alertId;
  }
  if (!Util.isUnset(request.algorithmAccurateDescribe)) {
    query['AlgorithmAccurateDescribe'] = request.algorithmAccurateDescribe;
  }
  if (!Util.isUnset(request.algorithmAccurateState)) {
    query['AlgorithmAccurateState'] = request.algorithmAccurateState;
  }
  if (!Util.isUnset(request.feedbackType)) {
    query['FeedbackType'] = request.feedbackType;
  }
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'FeedbackAlertAlgorithm',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function feedbackAlertAlgorithm(request: FeedbackAlertAlgorithmRequest): FeedbackAlertAlgorithmResponse {
  var runtime = new Util.RuntimeOptions{};
  return feedbackAlertAlgorithmWithOptions(request, runtime);
}

model GetAiopsEventListRequest {
  businessGroupId?: string(name='BusinessGroupId'),
  businessGroupName?: string(name='BusinessGroupName'),
  currentPage?: int32(name='CurrentPage'),
  eventType?: int32(name='EventType'),
  eventUniqueId?: string(name='EventUniqueId'),
  feedbackStatus?: int32(name='FeedbackStatus'),
  name?: string(name='Name'),
  operaUid?: string(name='OperaUid'),
  pageSize?: int32(name='PageSize'),
  predictionState?: int32(name='PredictionState'),
  severity?: int32(name='Severity'),
  status?: int32(name='Status'),
  uid?: long(name='Uid'),
}

model GetAiopsEventListResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  pageTotal?: int32(name='PageTotal'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetAiopsEventListResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetAiopsEventListResponseBody(name='body'),
}

async function getAiopsEventListWithOptions(request: GetAiopsEventListRequest, runtime: Util.RuntimeOptions): GetAiopsEventListResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.businessGroupId)) {
    query['BusinessGroupId'] = request.businessGroupId;
  }
  if (!Util.isUnset(request.businessGroupName)) {
    query['BusinessGroupName'] = request.businessGroupName;
  }
  if (!Util.isUnset(request.currentPage)) {
    query['CurrentPage'] = request.currentPage;
  }
  if (!Util.isUnset(request.eventType)) {
    query['EventType'] = request.eventType;
  }
  if (!Util.isUnset(request.eventUniqueId)) {
    query['EventUniqueId'] = request.eventUniqueId;
  }
  if (!Util.isUnset(request.feedbackStatus)) {
    query['FeedbackStatus'] = request.feedbackStatus;
  }
  if (!Util.isUnset(request.name)) {
    query['Name'] = request.name;
  }
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.predictionState)) {
    query['PredictionState'] = request.predictionState;
  }
  if (!Util.isUnset(request.severity)) {
    query['Severity'] = request.severity;
  }
  if (!Util.isUnset(request.status)) {
    query['Status'] = request.status;
  }
  if (!Util.isUnset(request.uid)) {
    query['Uid'] = request.uid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetAiopsEventList',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getAiopsEventList(request: GetAiopsEventListRequest): GetAiopsEventListResponse {
  var runtime = new Util.RuntimeOptions{};
  return getAiopsEventListWithOptions(request, runtime);
}

model GetAiopsEventNewListRequest {
  currentPage?: int32(name='CurrentPage'),
  operaUid?: string(name='OperaUid'),
  pageSize?: int32(name='PageSize'),
  uid?: long(name='Uid'),
}

model GetAiopsEventNewListResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  pageTotal?: long(name='PageTotal'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetAiopsEventNewListResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetAiopsEventNewListResponseBody(name='body'),
}

async function getAiopsEventNewListWithOptions(request: GetAiopsEventNewListRequest, runtime: Util.RuntimeOptions): GetAiopsEventNewListResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.currentPage)) {
    query['CurrentPage'] = request.currentPage;
  }
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.uid)) {
    query['Uid'] = request.uid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetAiopsEventNewList',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getAiopsEventNewList(request: GetAiopsEventNewListRequest): GetAiopsEventNewListResponse {
  var runtime = new Util.RuntimeOptions{};
  return getAiopsEventNewListWithOptions(request, runtime);
}

model GetAlertDetailTrendDataRequest {
  abnormalId?: long(name='AbnormalId'),
  alertId?: long(name='AlertId'),
  beginTime?: long(name='BeginTime'),
  endTime?: long(name='EndTime'),
  operaUid?: string(name='OperaUid'),
}

model GetAlertDetailTrendDataResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  pageTotal?: long(name='PageTotal'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetAlertDetailTrendDataResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetAlertDetailTrendDataResponseBody(name='body'),
}

async function getAlertDetailTrendDataWithOptions(request: GetAlertDetailTrendDataRequest, runtime: Util.RuntimeOptions): GetAlertDetailTrendDataResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.abnormalId)) {
    query['AbnormalId'] = request.abnormalId;
  }
  if (!Util.isUnset(request.alertId)) {
    query['AlertId'] = request.alertId;
  }
  if (!Util.isUnset(request.beginTime)) {
    query['BeginTime'] = request.beginTime;
  }
  if (!Util.isUnset(request.endTime)) {
    query['EndTime'] = request.endTime;
  }
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetAlertDetailTrendData',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getAlertDetailTrendData(request: GetAlertDetailTrendDataRequest): GetAlertDetailTrendDataResponse {
  var runtime = new Util.RuntimeOptions{};
  return getAlertDetailTrendDataWithOptions(request, runtime);
}

model GetAlertListRequest {
  aliUid?: string(name='AliUid'),
  eventId?: string(name='EventId'),
  operaUid?: string(name='OperaUid'),
}

model GetAlertListResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  message?: string(name='Message'),
  pageTotal?: int32(name='PageTotal'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetAlertListResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetAlertListResponseBody(name='body'),
}

async function getAlertListWithOptions(request: GetAlertListRequest, runtime: Util.RuntimeOptions): GetAlertListResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliUid)) {
    query['AliUid'] = request.aliUid;
  }
  if (!Util.isUnset(request.eventId)) {
    query['EventId'] = request.eventId;
  }
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetAlertList',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getAlertList(request: GetAlertListRequest): GetAlertListResponse {
  var runtime = new Util.RuntimeOptions{};
  return getAlertListWithOptions(request, runtime);
}

model GetAlertTrentRequest {
  aliUid?: string(name='AliUid'),
  eventId?: string(name='EventId'),
  operaUid?: string(name='OperaUid'),
}

model GetAlertTrentResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  message?: string(name='Message'),
  pageTotal?: int32(name='PageTotal'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetAlertTrentResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetAlertTrentResponseBody(name='body'),
}

async function getAlertTrentWithOptions(request: GetAlertTrentRequest, runtime: Util.RuntimeOptions): GetAlertTrentResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliUid)) {
    query['AliUid'] = request.aliUid;
  }
  if (!Util.isUnset(request.eventId)) {
    query['EventId'] = request.eventId;
  }
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetAlertTrent',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getAlertTrent(request: GetAlertTrentRequest): GetAlertTrentResponse {
  var runtime = new Util.RuntimeOptions{};
  return getAlertTrentWithOptions(request, runtime);
}

model GetAlgorithmRequest {
  expandInformation?: string(name='ExpandInformation'),
  instanceId?: string(name='InstanceId'),
  metricName?: string(name='MetricName'),
  operaUid?: string(name='OperaUid'),
  pageNum?: int32(name='PageNum'),
  pageSize?: int32(name='PageSize'),
}

model GetAlgorithmResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  pageTotal?: long(name='PageTotal'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetAlgorithmResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetAlgorithmResponseBody(name='body'),
}

async function getAlgorithmWithOptions(request: GetAlgorithmRequest, runtime: Util.RuntimeOptions): GetAlgorithmResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.expandInformation)) {
    query['ExpandInformation'] = request.expandInformation;
  }
  if (!Util.isUnset(request.instanceId)) {
    query['InstanceId'] = request.instanceId;
  }
  if (!Util.isUnset(request.metricName)) {
    query['MetricName'] = request.metricName;
  }
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  if (!Util.isUnset(request.pageNum)) {
    query['PageNum'] = request.pageNum;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetAlgorithm',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getAlgorithm(request: GetAlgorithmRequest): GetAlgorithmResponse {
  var runtime = new Util.RuntimeOptions{};
  return getAlgorithmWithOptions(request, runtime);
}

model GetAlgorithmConfigRequest {
  algorithmTypeCode?: string(name='AlgorithmTypeCode'),
  operaUid?: string(name='OperaUid'),
}

model GetAlgorithmConfigResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  pageTotal?: long(name='PageTotal'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetAlgorithmConfigResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetAlgorithmConfigResponseBody(name='body'),
}

async function getAlgorithmConfigWithOptions(request: GetAlgorithmConfigRequest, runtime: Util.RuntimeOptions): GetAlgorithmConfigResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.algorithmTypeCode)) {
    query['AlgorithmTypeCode'] = request.algorithmTypeCode;
  }
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetAlgorithmConfig',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getAlgorithmConfig(request: GetAlgorithmConfigRequest): GetAlgorithmConfigResponse {
  var runtime = new Util.RuntimeOptions{};
  return getAlgorithmConfigWithOptions(request, runtime);
}

model GetAlgorithmDataRequest {
  endTime?: long(name='EndTime'),
  id?: long(name='Id'),
  operaUid?: string(name='OperaUid'),
  startTime?: long(name='StartTime'),
}

model GetAlgorithmDataResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetAlgorithmDataResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetAlgorithmDataResponseBody(name='body'),
}

async function getAlgorithmDataWithOptions(request: GetAlgorithmDataRequest, runtime: Util.RuntimeOptions): GetAlgorithmDataResponse {
  Util.validateModel(request);
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetAlgorithmData',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getAlgorithmData(request: GetAlgorithmDataRequest): GetAlgorithmDataResponse {
  var runtime = new Util.RuntimeOptions{};
  return getAlgorithmDataWithOptions(request, runtime);
}

model GetAlgorithmDetailsRequest {
  id?: int32(name='Id'),
  operaUid?: string(name='OperaUid'),
  pageNum?: int32(name='PageNum'),
  pageSize?: int32(name='PageSize'),
}

model GetAlgorithmDetailsResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  pageTotal?: long(name='PageTotal'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetAlgorithmDetailsResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetAlgorithmDetailsResponseBody(name='body'),
}

async function getAlgorithmDetailsWithOptions(request: GetAlgorithmDetailsRequest, runtime: Util.RuntimeOptions): GetAlgorithmDetailsResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.id)) {
    query['Id'] = request.id;
  }
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  if (!Util.isUnset(request.pageNum)) {
    query['PageNum'] = request.pageNum;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetAlgorithmDetails',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getAlgorithmDetails(request: GetAlgorithmDetailsRequest): GetAlgorithmDetailsResponse {
  var runtime = new Util.RuntimeOptions{};
  return getAlgorithmDetailsWithOptions(request, runtime);
}

model GetAlgorithmForecastDataRequest {
  aliUid?: string(name='AliUid'),
  endTime?: long(name='EndTime'),
  id?: int32(name='Id'),
  operaUid?: string(name='OperaUid'),
  startTime?: long(name='StartTime'),
}

model GetAlgorithmForecastDataResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetAlgorithmForecastDataResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetAlgorithmForecastDataResponseBody(name='body'),
}

async function getAlgorithmForecastDataWithOptions(request: GetAlgorithmForecastDataRequest, runtime: Util.RuntimeOptions): GetAlgorithmForecastDataResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliUid)) {
    query['AliUid'] = request.aliUid;
  }
  if (!Util.isUnset(request.endTime)) {
    query['EndTime'] = request.endTime;
  }
  if (!Util.isUnset(request.id)) {
    query['Id'] = request.id;
  }
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  if (!Util.isUnset(request.startTime)) {
    query['StartTime'] = request.startTime;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetAlgorithmForecastData',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getAlgorithmForecastData(request: GetAlgorithmForecastDataRequest): GetAlgorithmForecastDataResponse {
  var runtime = new Util.RuntimeOptions{};
  return getAlgorithmForecastDataWithOptions(request, runtime);
}

model GetAlgorithmForecastDetailsRequest {
  aliUid?: string(name='AliUid'),
  id?: int32(name='Id'),
  operaUid?: string(name='OperaUid'),
}

model GetAlgorithmForecastDetailsResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetAlgorithmForecastDetailsResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetAlgorithmForecastDetailsResponseBody(name='body'),
}

async function getAlgorithmForecastDetailsWithOptions(request: GetAlgorithmForecastDetailsRequest, runtime: Util.RuntimeOptions): GetAlgorithmForecastDetailsResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliUid)) {
    query['AliUid'] = request.aliUid;
  }
  if (!Util.isUnset(request.id)) {
    query['Id'] = request.id;
  }
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetAlgorithmForecastDetails',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getAlgorithmForecastDetails(request: GetAlgorithmForecastDetailsRequest): GetAlgorithmForecastDetailsResponse {
  var runtime = new Util.RuntimeOptions{};
  return getAlgorithmForecastDetailsWithOptions(request, runtime);
}

model GetAlgorithmListRequest {
  algorithmType?: int32(name='AlgorithmType'),
  expandInformation?: string(name='ExpandInformation'),
  instanceId?: string(name='InstanceId'),
  metricName?: string(name='MetricName'),
  operaUid?: string(name='OperaUid'),
  pageNum?: int32(name='PageNum'),
  pageSize?: int32(name='PageSize'),
}

model GetAlgorithmListResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetAlgorithmListResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetAlgorithmListResponseBody(name='body'),
}

async function getAlgorithmListWithOptions(request: GetAlgorithmListRequest, runtime: Util.RuntimeOptions): GetAlgorithmListResponse {
  Util.validateModel(request);
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetAlgorithmList',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getAlgorithmList(request: GetAlgorithmListRequest): GetAlgorithmListResponse {
  var runtime = new Util.RuntimeOptions{};
  return getAlgorithmListWithOptions(request, runtime);
}

model GetAllAlgorithmConfigRequest {
  operaUid?: string(name='OperaUid'),
}

model GetAllAlgorithmConfigResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  pageTotal?: long(name='PageTotal'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetAllAlgorithmConfigResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetAllAlgorithmConfigResponseBody(name='body'),
}

async function getAllAlgorithmConfigWithOptions(request: GetAllAlgorithmConfigRequest, runtime: Util.RuntimeOptions): GetAllAlgorithmConfigResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetAllAlgorithmConfig',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getAllAlgorithmConfig(request: GetAllAlgorithmConfigRequest): GetAllAlgorithmConfigResponse {
  var runtime = new Util.RuntimeOptions{};
  return getAllAlgorithmConfigWithOptions(request, runtime);
}

model GetAllTagResourceNumListRequest {
  currentPage?: int32(name='CurrentPage'),
  operaUid?: string(name='OperaUid'),
  pageSize?: int32(name='PageSize'),
  productId?: long(name='ProductId'),
  tagName?: string(name='TagName'),
}

model GetAllTagResourceNumListResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  pageTotal?: int32(name='PageTotal'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetAllTagResourceNumListResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetAllTagResourceNumListResponseBody(name='body'),
}

async function getAllTagResourceNumListWithOptions(request: GetAllTagResourceNumListRequest, runtime: Util.RuntimeOptions): GetAllTagResourceNumListResponse {
  Util.validateModel(request);
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetAllTagResourceNumList',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getAllTagResourceNumList(request: GetAllTagResourceNumListRequest): GetAllTagResourceNumListResponse {
  var runtime = new Util.RuntimeOptions{};
  return getAllTagResourceNumListWithOptions(request, runtime);
}

model GetAnalysisProcessRequest {
  eventId?: string(name='EventId'),
  lang?: string(name='Lang'),
  operaUid?: string(name='OperaUid'),
}

model GetAnalysisProcessResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetAnalysisProcessResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetAnalysisProcessResponseBody(name='body'),
}

async function getAnalysisProcessWithOptions(request: GetAnalysisProcessRequest, runtime: Util.RuntimeOptions): GetAnalysisProcessResponse {
  Util.validateModel(request);
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetAnalysisProcess',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getAnalysisProcess(request: GetAnalysisProcessRequest): GetAnalysisProcessResponse {
  var runtime = new Util.RuntimeOptions{};
  return getAnalysisProcessWithOptions(request, runtime);
}

model GetAuthorizationRequest {
  userId?: string(name='UserId'),
}

model GetAuthorizationResponseBody = {
  code?: string(name='Code'),
  data?: boolean(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetAuthorizationResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetAuthorizationResponseBody(name='body'),
}

async function getAuthorizationWithOptions(request: GetAuthorizationRequest, runtime: Util.RuntimeOptions): GetAuthorizationResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.userId)) {
    query['UserId'] = request.userId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetAuthorization',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getAuthorization(request: GetAuthorizationRequest): GetAuthorizationResponse {
  var runtime = new Util.RuntimeOptions{};
  return getAuthorizationWithOptions(request, runtime);
}

model GetAvgRepairTimeRequest {
  operaUid?: string(name='OperaUid'),
  uid?: long(name='Uid'),
}

model GetAvgRepairTimeResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: boolean(name='Status'),
}

model GetAvgRepairTimeResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetAvgRepairTimeResponseBody(name='body'),
}

async function getAvgRepairTimeWithOptions(request: GetAvgRepairTimeRequest, runtime: Util.RuntimeOptions): GetAvgRepairTimeResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  if (!Util.isUnset(request.uid)) {
    query['Uid'] = request.uid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetAvgRepairTime',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getAvgRepairTime(request: GetAvgRepairTimeRequest): GetAvgRepairTimeResponse {
  var runtime = new Util.RuntimeOptions{};
  return getAvgRepairTimeWithOptions(request, runtime);
}

model GetBackScriptListRequest {
  operaUid?: string(name='OperaUid'),
  sceneId?: int32(name='SceneId'),
}

model GetBackScriptListResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetBackScriptListResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetBackScriptListResponseBody(name='body'),
}

async function getBackScriptListWithOptions(request: GetBackScriptListRequest, runtime: Util.RuntimeOptions): GetBackScriptListResponse {
  Util.validateModel(request);
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetBackScriptList',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getBackScriptList(request: GetBackScriptListRequest): GetBackScriptListResponse {
  var runtime = new Util.RuntimeOptions{};
  return getBackScriptListWithOptions(request, runtime);
}

model GetBusinessGroupRequest {
  operaUid?: string(name='OperaUid'),
}

model GetBusinessGroupResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetBusinessGroupResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetBusinessGroupResponseBody(name='body'),
}

async function getBusinessGroupWithOptions(request: GetBusinessGroupRequest, runtime: Util.RuntimeOptions): GetBusinessGroupResponse {
  Util.validateModel(request);
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetBusinessGroup',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getBusinessGroup(request: GetBusinessGroupRequest): GetBusinessGroupResponse {
  var runtime = new Util.RuntimeOptions{};
  return getBusinessGroupWithOptions(request, runtime);
}

model GetBusinessGroupAllRequest {
  businessGroupName?: string(name='BusinessGroupName'),
  currentPage?: long(name='CurrentPage'),
  operaUid?: string(name='OperaUid'),
  pageSize?: long(name='PageSize'),
  status?: long(name='Status'),
}

model GetBusinessGroupAllResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  pageTotal?: long(name='PageTotal'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetBusinessGroupAllResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetBusinessGroupAllResponseBody(name='body'),
}

async function getBusinessGroupAllWithOptions(request: GetBusinessGroupAllRequest, runtime: Util.RuntimeOptions): GetBusinessGroupAllResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.businessGroupName)) {
    query['BusinessGroupName'] = request.businessGroupName;
  }
  if (!Util.isUnset(request.currentPage)) {
    query['CurrentPage'] = request.currentPage;
  }
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.status)) {
    query['Status'] = request.status;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetBusinessGroupAll',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getBusinessGroupAll(request: GetBusinessGroupAllRequest): GetBusinessGroupAllResponse {
  var runtime = new Util.RuntimeOptions{};
  return getBusinessGroupAllWithOptions(request, runtime);
}

model GetBusinessGroupIndexRequest {
  businessGroupId?: string(name='BusinessGroupId'),
  operaUid?: string(name='OperaUid'),
  productId?: int32(name='ProductId'),
}

model GetBusinessGroupIndexResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetBusinessGroupIndexResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetBusinessGroupIndexResponseBody(name='body'),
}

async function getBusinessGroupIndexWithOptions(request: GetBusinessGroupIndexRequest, runtime: Util.RuntimeOptions): GetBusinessGroupIndexResponse {
  Util.validateModel(request);
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetBusinessGroupIndex',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getBusinessGroupIndex(request: GetBusinessGroupIndexRequest): GetBusinessGroupIndexResponse {
  var runtime = new Util.RuntimeOptions{};
  return getBusinessGroupIndexWithOptions(request, runtime);
}

model GetBusinessGroupInfoRequest {
  businessGroupId?: string(name='BusinessGroupId'),
  operaUid?: string(name='OperaUid'),
}

model GetBusinessGroupInfoResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: boolean(name='Status'),
}

model GetBusinessGroupInfoResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetBusinessGroupInfoResponseBody(name='body'),
}

async function getBusinessGroupInfoWithOptions(request: GetBusinessGroupInfoRequest, runtime: Util.RuntimeOptions): GetBusinessGroupInfoResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.businessGroupId)) {
    query['BusinessGroupId'] = request.businessGroupId;
  }
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetBusinessGroupInfo',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getBusinessGroupInfo(request: GetBusinessGroupInfoRequest): GetBusinessGroupInfoResponse {
  var runtime = new Util.RuntimeOptions{};
  return getBusinessGroupInfoWithOptions(request, runtime);
}

model GetBusinessGroupOverviewListRequest {
  aliUid?: string(name='AliUid'),
  currentPage?: int32(name='CurrentPage'),
  operaUid?: string(name='OperaUid'),
  pageSize?: int32(name='PageSize'),
}

model GetBusinessGroupOverviewListResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  pageTotal?: int32(name='PageTotal'),
  requestId?: string(name='RequestId'),
  status?: boolean(name='Status'),
}

model GetBusinessGroupOverviewListResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetBusinessGroupOverviewListResponseBody(name='body'),
}

async function getBusinessGroupOverviewListWithOptions(request: GetBusinessGroupOverviewListRequest, runtime: Util.RuntimeOptions): GetBusinessGroupOverviewListResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliUid)) {
    query['AliUid'] = request.aliUid;
  }
  if (!Util.isUnset(request.currentPage)) {
    query['CurrentPage'] = request.currentPage;
  }
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetBusinessGroupOverviewList',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getBusinessGroupOverviewList(request: GetBusinessGroupOverviewListRequest): GetBusinessGroupOverviewListResponse {
  var runtime = new Util.RuntimeOptions{};
  return getBusinessGroupOverviewListWithOptions(request, runtime);
}

model GetBusinessLogAlertDetailRequest {
  id?: long(name='Id'),
  operaUid?: string(name='OperaUid'),
}

model GetBusinessLogAlertDetailResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  pageTotal?: long(name='PageTotal'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetBusinessLogAlertDetailResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetBusinessLogAlertDetailResponseBody(name='body'),
}

async function getBusinessLogAlertDetailWithOptions(request: GetBusinessLogAlertDetailRequest, runtime: Util.RuntimeOptions): GetBusinessLogAlertDetailResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.id)) {
    query['Id'] = request.id;
  }
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetBusinessLogAlertDetail',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getBusinessLogAlertDetail(request: GetBusinessLogAlertDetailRequest): GetBusinessLogAlertDetailResponse {
  var runtime = new Util.RuntimeOptions{};
  return getBusinessLogAlertDetailWithOptions(request, runtime);
}

model GetBusinessLogAlertListRequest {
  eventId?: long(name='EventId'),
  operaUid?: string(name='OperaUid'),
}

model GetBusinessLogAlertListResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  pageTotal?: long(name='PageTotal'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetBusinessLogAlertListResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetBusinessLogAlertListResponseBody(name='body'),
}

async function getBusinessLogAlertListWithOptions(request: GetBusinessLogAlertListRequest, runtime: Util.RuntimeOptions): GetBusinessLogAlertListResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.eventId)) {
    query['EventId'] = request.eventId;
  }
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetBusinessLogAlertList',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getBusinessLogAlertList(request: GetBusinessLogAlertListRequest): GetBusinessLogAlertListResponse {
  var runtime = new Util.RuntimeOptions{};
  return getBusinessLogAlertListWithOptions(request, runtime);
}

model GetBusinessLogAlertTopNRequest {
  alertType?: string(name='AlertType'),
  eventId?: string(name='EventId'),
  operaUid?: string(name='OperaUid'),
  topNum?: long(name='TopNum'),
}

model GetBusinessLogAlertTopNResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  pageTotal?: long(name='PageTotal'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetBusinessLogAlertTopNResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetBusinessLogAlertTopNResponseBody(name='body'),
}

async function getBusinessLogAlertTopNWithOptions(request: GetBusinessLogAlertTopNRequest, runtime: Util.RuntimeOptions): GetBusinessLogAlertTopNResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.alertType)) {
    query['AlertType'] = request.alertType;
  }
  if (!Util.isUnset(request.eventId)) {
    query['EventId'] = request.eventId;
  }
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  if (!Util.isUnset(request.topNum)) {
    query['TopNum'] = request.topNum;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetBusinessLogAlertTopN',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getBusinessLogAlertTopN(request: GetBusinessLogAlertTopNRequest): GetBusinessLogAlertTopNResponse {
  var runtime = new Util.RuntimeOptions{};
  return getBusinessLogAlertTopNWithOptions(request, runtime);
}

model GetBusinessMetricAlertDetailListRequest {
  eventId?: string(name='EventId'),
  id?: long(name='Id'),
  metricName?: string(name='MetricName'),
  operaUid?: string(name='OperaUid'),
}

model GetBusinessMetricAlertDetailListResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetBusinessMetricAlertDetailListResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetBusinessMetricAlertDetailListResponseBody(name='body'),
}

async function getBusinessMetricAlertDetailListWithOptions(request: GetBusinessMetricAlertDetailListRequest, runtime: Util.RuntimeOptions): GetBusinessMetricAlertDetailListResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.eventId)) {
    query['EventId'] = request.eventId;
  }
  if (!Util.isUnset(request.id)) {
    query['Id'] = request.id;
  }
  if (!Util.isUnset(request.metricName)) {
    query['MetricName'] = request.metricName;
  }
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetBusinessMetricAlertDetailList',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getBusinessMetricAlertDetailList(request: GetBusinessMetricAlertDetailListRequest): GetBusinessMetricAlertDetailListResponse {
  var runtime = new Util.RuntimeOptions{};
  return getBusinessMetricAlertDetailListWithOptions(request, runtime);
}

model GetBusinessMetricAlertListRequest {
  eventId?: string(name='EventId'),
  operaUid?: string(name='OperaUid'),
}

model GetBusinessMetricAlertListResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetBusinessMetricAlertListResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetBusinessMetricAlertListResponseBody(name='body'),
}

async function getBusinessMetricAlertListWithOptions(request: GetBusinessMetricAlertListRequest, runtime: Util.RuntimeOptions): GetBusinessMetricAlertListResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.eventId)) {
    query['EventId'] = request.eventId;
  }
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetBusinessMetricAlertList',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getBusinessMetricAlertList(request: GetBusinessMetricAlertListRequest): GetBusinessMetricAlertListResponse {
  var runtime = new Util.RuntimeOptions{};
  return getBusinessMetricAlertListWithOptions(request, runtime);
}

model GetBusinessMetricAlertTopNRequest {
  alertType?: string(name='AlertType'),
  eventId?: string(name='EventId'),
  operaUid?: string(name='OperaUid'),
  topNum?: long(name='TopNum'),
}

model GetBusinessMetricAlertTopNResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  pageTotal?: long(name='PageTotal'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetBusinessMetricAlertTopNResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetBusinessMetricAlertTopNResponseBody(name='body'),
}

async function getBusinessMetricAlertTopNWithOptions(request: GetBusinessMetricAlertTopNRequest, runtime: Util.RuntimeOptions): GetBusinessMetricAlertTopNResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.alertType)) {
    query['AlertType'] = request.alertType;
  }
  if (!Util.isUnset(request.eventId)) {
    query['EventId'] = request.eventId;
  }
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  if (!Util.isUnset(request.topNum)) {
    query['TopNum'] = request.topNum;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetBusinessMetricAlertTopN',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getBusinessMetricAlertTopN(request: GetBusinessMetricAlertTopNRequest): GetBusinessMetricAlertTopNResponse {
  var runtime = new Util.RuntimeOptions{};
  return getBusinessMetricAlertTopNWithOptions(request, runtime);
}

model GetBusinessMetricAllListRequest {
  operaUid?: string(name='OperaUid'),
}

model GetBusinessMetricAllListResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetBusinessMetricAllListResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetBusinessMetricAllListResponseBody(name='body'),
}

async function getBusinessMetricAllListWithOptions(request: GetBusinessMetricAllListRequest, runtime: Util.RuntimeOptions): GetBusinessMetricAllListResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetBusinessMetricAllList',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getBusinessMetricAllList(request: GetBusinessMetricAllListRequest): GetBusinessMetricAllListResponse {
  var runtime = new Util.RuntimeOptions{};
  return getBusinessMetricAllListWithOptions(request, runtime);
}

model GetBusinessMetricForecastListRequest {
  eventId?: string(name='EventId'),
  operaUid?: string(name='OperaUid'),
}

model GetBusinessMetricForecastListResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetBusinessMetricForecastListResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetBusinessMetricForecastListResponseBody(name='body'),
}

async function getBusinessMetricForecastListWithOptions(request: GetBusinessMetricForecastListRequest, runtime: Util.RuntimeOptions): GetBusinessMetricForecastListResponse {
  Util.validateModel(request);
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetBusinessMetricForecastList',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getBusinessMetricForecastList(request: GetBusinessMetricForecastListRequest): GetBusinessMetricForecastListResponse {
  var runtime = new Util.RuntimeOptions{};
  return getBusinessMetricForecastListWithOptions(request, runtime);
}

model GetBusinessMetricResourceByMetricIdRequest {
  id?: long(name='Id'),
  operaUid?: string(name='OperaUid'),
}

model GetBusinessMetricResourceByMetricIdResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  pageTotal?: long(name='PageTotal'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetBusinessMetricResourceByMetricIdResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetBusinessMetricResourceByMetricIdResponseBody(name='body'),
}

async function getBusinessMetricResourceByMetricIdWithOptions(request: GetBusinessMetricResourceByMetricIdRequest, runtime: Util.RuntimeOptions): GetBusinessMetricResourceByMetricIdResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.id)) {
    query['Id'] = request.id;
  }
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetBusinessMetricResourceByMetricId',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getBusinessMetricResourceByMetricId(request: GetBusinessMetricResourceByMetricIdRequest): GetBusinessMetricResourceByMetricIdResponse {
  var runtime = new Util.RuntimeOptions{};
  return getBusinessMetricResourceByMetricIdWithOptions(request, runtime);
}

model GetBusinessMetricSceneListRequest {
  id?: long(name='Id'),
  operaUid?: string(name='OperaUid'),
}

model GetBusinessMetricSceneListResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetBusinessMetricSceneListResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetBusinessMetricSceneListResponseBody(name='body'),
}

async function getBusinessMetricSceneListWithOptions(request: GetBusinessMetricSceneListRequest, runtime: Util.RuntimeOptions): GetBusinessMetricSceneListResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.id)) {
    query['Id'] = request.id;
  }
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetBusinessMetricSceneList',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getBusinessMetricSceneList(request: GetBusinessMetricSceneListRequest): GetBusinessMetricSceneListResponse {
  var runtime = new Util.RuntimeOptions{};
  return getBusinessMetricSceneListWithOptions(request, runtime);
}

model GetCidInfoRequest {
  uid?: long(name='Uid'),
}

model GetCidInfoResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetCidInfoResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetCidInfoResponseBody(name='body'),
}

async function getCidInfoWithOptions(request: GetCidInfoRequest, runtime: Util.RuntimeOptions): GetCidInfoResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.uid)) {
    query['Uid'] = request.uid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetCidInfo',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getCidInfo(request: GetCidInfoRequest): GetCidInfoResponse {
  var runtime = new Util.RuntimeOptions{};
  return getCidInfoWithOptions(request, runtime);
}

model GetCloudAllResourceListRequest {
  operaUid?: string(name='OperaUid'),
  uid?: string(name='Uid'),
}

model GetCloudAllResourceListResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: boolean(name='Status'),
}

model GetCloudAllResourceListResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetCloudAllResourceListResponseBody(name='body'),
}

async function getCloudAllResourceListWithOptions(request: GetCloudAllResourceListRequest, runtime: Util.RuntimeOptions): GetCloudAllResourceListResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  if (!Util.isUnset(request.uid)) {
    query['Uid'] = request.uid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetCloudAllResourceList',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getCloudAllResourceList(request: GetCloudAllResourceListRequest): GetCloudAllResourceListResponse {
  var runtime = new Util.RuntimeOptions{};
  return getCloudAllResourceListWithOptions(request, runtime);
}

model GetCloudResourceRequest {
  cloudTypeName?: string(name='CloudTypeName'),
  currentPage?: int32(name='CurrentPage'),
  operaUid?: string(name='OperaUid'),
  pageSize?: int32(name='PageSize'),
  status?: int32(name='Status'),
}

model GetCloudResourceResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  pageTotal?: long(name='PageTotal'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetCloudResourceResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetCloudResourceResponseBody(name='body'),
}

async function getCloudResourceWithOptions(request: GetCloudResourceRequest, runtime: Util.RuntimeOptions): GetCloudResourceResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.cloudTypeName)) {
    query['CloudTypeName'] = request.cloudTypeName;
  }
  if (!Util.isUnset(request.currentPage)) {
    query['CurrentPage'] = request.currentPage;
  }
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.status)) {
    query['Status'] = request.status;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetCloudResource',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getCloudResource(request: GetCloudResourceRequest): GetCloudResourceResponse {
  var runtime = new Util.RuntimeOptions{};
  return getCloudResourceWithOptions(request, runtime);
}

model GetCloudResourceListRequest {
  businessGroupId?: string(name='BusinessGroupId'),
  cloudRegionId?: string(name='CloudRegionId'),
  currentPage?: int32(name='CurrentPage'),
  id?: string(name='Id'),
  instanceId?: string(name='InstanceId'),
  instanceName?: string(name='InstanceName'),
  isOptional?: int32(name='IsOptional'),
  operaUid?: string(name='OperaUid'),
  pageSize?: int32(name='PageSize'),
  privateIp?: string(name='PrivateIp'),
  releaseStatus?: int32(name='ReleaseStatus'),
  tagName?: string(name='TagName'),
  uid?: string(name='Uid'),
}

model GetCloudResourceListResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  pageTotal?: long(name='PageTotal'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetCloudResourceListResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetCloudResourceListResponseBody(name='body'),
}

async function getCloudResourceListWithOptions(request: GetCloudResourceListRequest, runtime: Util.RuntimeOptions): GetCloudResourceListResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.businessGroupId)) {
    query['BusinessGroupId'] = request.businessGroupId;
  }
  if (!Util.isUnset(request.cloudRegionId)) {
    query['CloudRegionId'] = request.cloudRegionId;
  }
  if (!Util.isUnset(request.currentPage)) {
    query['CurrentPage'] = request.currentPage;
  }
  if (!Util.isUnset(request.id)) {
    query['Id'] = request.id;
  }
  if (!Util.isUnset(request.instanceId)) {
    query['InstanceId'] = request.instanceId;
  }
  if (!Util.isUnset(request.instanceName)) {
    query['InstanceName'] = request.instanceName;
  }
  if (!Util.isUnset(request.isOptional)) {
    query['IsOptional'] = request.isOptional;
  }
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.privateIp)) {
    query['PrivateIp'] = request.privateIp;
  }
  if (!Util.isUnset(request.releaseStatus)) {
    query['ReleaseStatus'] = request.releaseStatus;
  }
  if (!Util.isUnset(request.tagName)) {
    query['TagName'] = request.tagName;
  }
  if (!Util.isUnset(request.uid)) {
    query['Uid'] = request.uid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetCloudResourceList',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getCloudResourceList(request: GetCloudResourceListRequest): GetCloudResourceListResponse {
  var runtime = new Util.RuntimeOptions{};
  return getCloudResourceListWithOptions(request, runtime);
}

model GetConnectInstancesRequest {
  uid?: long(name='Uid'),
}

model GetConnectInstancesResponseBody = {
  code?: long(name='Code'),
  data?: [  map[string]any ](name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetConnectInstancesResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetConnectInstancesResponseBody(name='body'),
}

async function getConnectInstancesWithOptions(request: GetConnectInstancesRequest, runtime: Util.RuntimeOptions): GetConnectInstancesResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.uid)) {
    query['Uid'] = request.uid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetConnectInstances',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getConnectInstances(request: GetConnectInstancesRequest): GetConnectInstancesResponse {
  var runtime = new Util.RuntimeOptions{};
  return getConnectInstancesWithOptions(request, runtime);
}

model GetDataSourceDetailRequest {
  id?: long(name='Id'),
  operaUid?: string(name='OperaUid'),
}

model GetDataSourceDetailResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetDataSourceDetailResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetDataSourceDetailResponseBody(name='body'),
}

async function getDataSourceDetailWithOptions(request: GetDataSourceDetailRequest, runtime: Util.RuntimeOptions): GetDataSourceDetailResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.id)) {
    query['Id'] = request.id;
  }
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetDataSourceDetail',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getDataSourceDetail(request: GetDataSourceDetailRequest): GetDataSourceDetailResponse {
  var runtime = new Util.RuntimeOptions{};
  return getDataSourceDetailWithOptions(request, runtime);
}

model GetDataSourceListRequest {
  currentPage?: int32(name='CurrentPage'),
  dataSourceName?: string(name='DataSourceName'),
  dataSourceType?: int32(name='DataSourceType'),
  operaUid?: string(name='OperaUid'),
  pageSize?: int32(name='PageSize'),
}

model GetDataSourceListResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  pageTotal?: long(name='PageTotal'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetDataSourceListResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetDataSourceListResponseBody(name='body'),
}

async function getDataSourceListWithOptions(request: GetDataSourceListRequest, runtime: Util.RuntimeOptions): GetDataSourceListResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.currentPage)) {
    query['CurrentPage'] = request.currentPage;
  }
  if (!Util.isUnset(request.dataSourceName)) {
    query['DataSourceName'] = request.dataSourceName;
  }
  if (!Util.isUnset(request.dataSourceType)) {
    query['DataSourceType'] = request.dataSourceType;
  }
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetDataSourceList',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getDataSourceList(request: GetDataSourceListRequest): GetDataSourceListResponse {
  var runtime = new Util.RuntimeOptions{};
  return getDataSourceListWithOptions(request, runtime);
}

model GetDataSourceTargetParamListRequest {
  dataSourceType?: int32(name='DataSourceType'),
  operaUid?: string(name='OperaUid'),
}

model GetDataSourceTargetParamListResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetDataSourceTargetParamListResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetDataSourceTargetParamListResponseBody(name='body'),
}

async function getDataSourceTargetParamListWithOptions(request: GetDataSourceTargetParamListRequest, runtime: Util.RuntimeOptions): GetDataSourceTargetParamListResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.dataSourceType)) {
    query['DataSourceType'] = request.dataSourceType;
  }
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetDataSourceTargetParamList',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getDataSourceTargetParamList(request: GetDataSourceTargetParamListRequest): GetDataSourceTargetParamListResponse {
  var runtime = new Util.RuntimeOptions{};
  return getDataSourceTargetParamListWithOptions(request, runtime);
}

model GetDataVolumeRequest {
  operaUid?: string(name='OperaUid'),
}

model GetDataVolumeResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetDataVolumeResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetDataVolumeResponseBody(name='body'),
}

async function getDataVolumeWithOptions(request: GetDataVolumeRequest, runtime: Util.RuntimeOptions): GetDataVolumeResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetDataVolume',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getDataVolume(request: GetDataVolumeRequest): GetDataVolumeResponse {
  var runtime = new Util.RuntimeOptions{};
  return getDataVolumeWithOptions(request, runtime);
}

model GetDiagInfoRequest {
  currentPage?: int32(name='CurrentPage'),
  diagnosticId?: string(name='DiagnosticId'),
  endTime?: long(name='EndTime'),
  pageSize?: int32(name='PageSize'),
  startTime?: long(name='StartTime'),
  status?: string(name='Status'),
  uid?: long(name='Uid'),
}

model GetDiagInfoResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  pageTotal?: long(name='PageTotal'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetDiagInfoResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetDiagInfoResponseBody(name='body'),
}

async function getDiagInfoWithOptions(request: GetDiagInfoRequest, runtime: Util.RuntimeOptions): GetDiagInfoResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.currentPage)) {
    query['CurrentPage'] = request.currentPage;
  }
  if (!Util.isUnset(request.diagnosticId)) {
    query['DiagnosticId'] = request.diagnosticId;
  }
  if (!Util.isUnset(request.endTime)) {
    query['EndTime'] = request.endTime;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.startTime)) {
    query['StartTime'] = request.startTime;
  }
  if (!Util.isUnset(request.status)) {
    query['Status'] = request.status;
  }
  if (!Util.isUnset(request.uid)) {
    query['Uid'] = request.uid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetDiagInfo',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getDiagInfo(request: GetDiagInfoRequest): GetDiagInfoResponse {
  var runtime = new Util.RuntimeOptions{};
  return getDiagInfoWithOptions(request, runtime);
}

model GetDomainConfigRequest {
  businessGroupId?: string(name='BusinessGroupId'),
  eventId?: string(name='EventId'),
  operaUid?: string(name='OperaUid'),
  productId?: int32(name='ProductId'),
}

model GetDomainConfigResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetDomainConfigResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetDomainConfigResponseBody(name='body'),
}

async function getDomainConfigWithOptions(request: GetDomainConfigRequest, runtime: Util.RuntimeOptions): GetDomainConfigResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.businessGroupId)) {
    query['BusinessGroupId'] = request.businessGroupId;
  }
  if (!Util.isUnset(request.eventId)) {
    query['EventId'] = request.eventId;
  }
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  if (!Util.isUnset(request.productId)) {
    query['ProductId'] = request.productId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetDomainConfig',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getDomainConfig(request: GetDomainConfigRequest): GetDomainConfigResponse {
  var runtime = new Util.RuntimeOptions{};
  return getDomainConfigWithOptions(request, runtime);
}

model GetEventAbNormalDetailRequest {
  id?: string(name='Id'),
  operaUid?: string(name='OperaUid'),
}

model GetEventAbNormalDetailResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetEventAbNormalDetailResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetEventAbNormalDetailResponseBody(name='body'),
}

async function getEventAbNormalDetailWithOptions(request: GetEventAbNormalDetailRequest, runtime: Util.RuntimeOptions): GetEventAbNormalDetailResponse {
  Util.validateModel(request);
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetEventAbNormalDetail',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getEventAbNormalDetail(request: GetEventAbNormalDetailRequest): GetEventAbNormalDetailResponse {
  var runtime = new Util.RuntimeOptions{};
  return getEventAbNormalDetailWithOptions(request, runtime);
}

model GetEventAbNormalDetailTrendDataRequest {
  beginTime?: long(name='BeginTime'),
  endTime?: long(name='EndTime'),
  id?: string(name='Id'),
  operaUid?: string(name='OperaUid'),
}

model GetEventAbNormalDetailTrendDataResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetEventAbNormalDetailTrendDataResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetEventAbNormalDetailTrendDataResponseBody(name='body'),
}

async function getEventAbNormalDetailTrendDataWithOptions(request: GetEventAbNormalDetailTrendDataRequest, runtime: Util.RuntimeOptions): GetEventAbNormalDetailTrendDataResponse {
  Util.validateModel(request);
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetEventAbNormalDetailTrendData',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getEventAbNormalDetailTrendData(request: GetEventAbNormalDetailTrendDataRequest): GetEventAbNormalDetailTrendDataResponse {
  var runtime = new Util.RuntimeOptions{};
  return getEventAbNormalDetailTrendDataWithOptions(request, runtime);
}

model GetEventAbNormalListRequest {
  eventId?: string(name='EventId'),
  operaUid?: string(name='OperaUid'),
}

model GetEventAbNormalListResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetEventAbNormalListResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetEventAbNormalListResponseBody(name='body'),
}

async function getEventAbNormalListWithOptions(request: GetEventAbNormalListRequest, runtime: Util.RuntimeOptions): GetEventAbNormalListResponse {
  Util.validateModel(request);
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetEventAbNormalList',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getEventAbNormalList(request: GetEventAbNormalListRequest): GetEventAbNormalListResponse {
  var runtime = new Util.RuntimeOptions{};
  return getEventAbNormalListWithOptions(request, runtime);
}

model GetEventBusinessMetricListRequest {
  eventId?: string(name='EventId'),
  operaUid?: string(name='OperaUid'),
}

model GetEventBusinessMetricListResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetEventBusinessMetricListResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetEventBusinessMetricListResponseBody(name='body'),
}

async function getEventBusinessMetricListWithOptions(request: GetEventBusinessMetricListRequest, runtime: Util.RuntimeOptions): GetEventBusinessMetricListResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.eventId)) {
    query['EventId'] = request.eventId;
  }
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetEventBusinessMetricList',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getEventBusinessMetricList(request: GetEventBusinessMetricListRequest): GetEventBusinessMetricListResponse {
  var runtime = new Util.RuntimeOptions{};
  return getEventBusinessMetricListWithOptions(request, runtime);
}

model GetEventDetailRequest {
  eventId?: string(name='EventId'),
  id?: long(name='Id'),
  operaUid?: string(name='OperaUid'),
}

model GetEventDetailResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetEventDetailResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetEventDetailResponseBody(name='body'),
}

async function getEventDetailWithOptions(request: GetEventDetailRequest, runtime: Util.RuntimeOptions): GetEventDetailResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.eventId)) {
    query['EventId'] = request.eventId;
  }
  if (!Util.isUnset(request.id)) {
    query['Id'] = request.id;
  }
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetEventDetail',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getEventDetail(request: GetEventDetailRequest): GetEventDetailResponse {
  var runtime = new Util.RuntimeOptions{};
  return getEventDetailWithOptions(request, runtime);
}

model GetEventRootCauseRequest {
  eventId?: string(name='EventId'),
  operaUid?: string(name='OperaUid'),
}

model GetEventRootCauseResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  pageTotal?: int32(name='PageTotal'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetEventRootCauseResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetEventRootCauseResponseBody(name='body'),
}

async function getEventRootCauseWithOptions(request: GetEventRootCauseRequest, runtime: Util.RuntimeOptions): GetEventRootCauseResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.eventId)) {
    query['EventId'] = request.eventId;
  }
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetEventRootCause',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getEventRootCause(request: GetEventRootCauseRequest): GetEventRootCauseResponse {
  var runtime = new Util.RuntimeOptions{};
  return getEventRootCauseWithOptions(request, runtime);
}

model GetEventSequentialTrentRequest {
  aliUid?: string(name='AliUid'),
  eventId?: string(name='EventId'),
  operaUid?: string(name='OperaUid'),
}

model GetEventSequentialTrentResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  message?: string(name='Message'),
  pageTotal?: int32(name='PageTotal'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetEventSequentialTrentResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetEventSequentialTrentResponseBody(name='body'),
}

async function getEventSequentialTrentWithOptions(request: GetEventSequentialTrentRequest, runtime: Util.RuntimeOptions): GetEventSequentialTrentResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliUid)) {
    query['AliUid'] = request.aliUid;
  }
  if (!Util.isUnset(request.eventId)) {
    query['EventId'] = request.eventId;
  }
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetEventSequentialTrent',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getEventSequentialTrent(request: GetEventSequentialTrentRequest): GetEventSequentialTrentResponse {
  var runtime = new Util.RuntimeOptions{};
  return getEventSequentialTrentWithOptions(request, runtime);
}

model GetEventStatisticsRequest {
  endTime?: string(name='EndTime'),
  operaUid?: string(name='OperaUid'),
  startTime?: string(name='StartTime'),
  uid?: long(name='Uid'),
}

model GetEventStatisticsResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetEventStatisticsResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetEventStatisticsResponseBody(name='body'),
}

async function getEventStatisticsWithOptions(request: GetEventStatisticsRequest, runtime: Util.RuntimeOptions): GetEventStatisticsResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.endTime)) {
    query['EndTime'] = request.endTime;
  }
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  if (!Util.isUnset(request.startTime)) {
    query['StartTime'] = request.startTime;
  }
  if (!Util.isUnset(request.uid)) {
    query['Uid'] = request.uid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetEventStatistics',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getEventStatistics(request: GetEventStatisticsRequest): GetEventStatisticsResponse {
  var runtime = new Util.RuntimeOptions{};
  return getEventStatisticsWithOptions(request, runtime);
}

model GetEventTrentRequest {
  endTime?: string(name='EndTime'),
  granularityType?: string(name='GranularityType'),
  operaUid?: string(name='OperaUid'),
  startTime?: string(name='StartTime'),
  timeType?: string(name='TimeType'),
  uid?: long(name='Uid'),
}

model GetEventTrentResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  pageTotal?: long(name='PageTotal'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetEventTrentResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetEventTrentResponseBody(name='body'),
}

async function getEventTrentWithOptions(request: GetEventTrentRequest, runtime: Util.RuntimeOptions): GetEventTrentResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.endTime)) {
    query['EndTime'] = request.endTime;
  }
  if (!Util.isUnset(request.granularityType)) {
    query['GranularityType'] = request.granularityType;
  }
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  if (!Util.isUnset(request.startTime)) {
    query['StartTime'] = request.startTime;
  }
  if (!Util.isUnset(request.timeType)) {
    query['TimeType'] = request.timeType;
  }
  if (!Util.isUnset(request.uid)) {
    query['Uid'] = request.uid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetEventTrent',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getEventTrent(request: GetEventTrentRequest): GetEventTrentResponse {
  var runtime = new Util.RuntimeOptions{};
  return getEventTrentWithOptions(request, runtime);
}

model GetEventTypeRequest {
  businessGroupId?: string(name='BusinessGroupId'),
  id?: long(name='Id'),
  operaUid?: string(name='OperaUid'),
  productId?: int32(name='ProductId'),
}

model GetEventTypeResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetEventTypeResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetEventTypeResponseBody(name='body'),
}

async function getEventTypeWithOptions(request: GetEventTypeRequest, runtime: Util.RuntimeOptions): GetEventTypeResponse {
  Util.validateModel(request);
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetEventType',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getEventType(request: GetEventTypeRequest): GetEventTypeResponse {
  var runtime = new Util.RuntimeOptions{};
  return getEventTypeWithOptions(request, runtime);
}

model GetExceptionsRequest {
  operaUid?: string(name='OperaUid'),
}

model GetExceptionsResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetExceptionsResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetExceptionsResponseBody(name='body'),
}

async function getExceptionsWithOptions(request: GetExceptionsRequest, runtime: Util.RuntimeOptions): GetExceptionsResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetExceptions',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getExceptions(request: GetExceptionsRequest): GetExceptionsResponse {
  var runtime = new Util.RuntimeOptions{};
  return getExceptionsWithOptions(request, runtime);
}

model GetExtendRequest {
  instanceId?: string(name='InstanceId'),
  metricId?: string(name='MetricId'),
  operaUid?: string(name='OperaUid'),
}

model GetExtendResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
}

async function getExtendWithOptions(request: GetExtendRequest, runtime: Util.RuntimeOptions): GetExtendResponse {
  Util.validateModel(request);
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetExtend',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'none',
  };
  return callApi(params, req, runtime);
}

async function getExtend(request: GetExtendRequest): GetExtendResponse {
  var runtime = new Util.RuntimeOptions{};
  return getExtendWithOptions(request, runtime);
}

model GetForecastBusinessMetricRequest {
  eventId?: string(name='EventId'),
  operaUid?: string(name='OperaUid'),
}

model GetForecastBusinessMetricResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetForecastBusinessMetricResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetForecastBusinessMetricResponseBody(name='body'),
}

async function getForecastBusinessMetricWithOptions(request: GetForecastBusinessMetricRequest, runtime: Util.RuntimeOptions): GetForecastBusinessMetricResponse {
  Util.validateModel(request);
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetForecastBusinessMetric',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getForecastBusinessMetric(request: GetForecastBusinessMetricRequest): GetForecastBusinessMetricResponse {
  var runtime = new Util.RuntimeOptions{};
  return getForecastBusinessMetricWithOptions(request, runtime);
}

model GetFunctionValidInfoRequest {
  functionName?: string(name='FunctionName'),
  operaUid?: string(name='OperaUid'),
  regionCode?: string(name='RegionCode'),
  serviceName?: string(name='ServiceName'),
}

model GetFunctionValidInfoResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetFunctionValidInfoResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetFunctionValidInfoResponseBody(name='body'),
}

async function getFunctionValidInfoWithOptions(request: GetFunctionValidInfoRequest, runtime: Util.RuntimeOptions): GetFunctionValidInfoResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.functionName)) {
    body['FunctionName'] = request.functionName;
  }
  if (!Util.isUnset(request.operaUid)) {
    body['OperaUid'] = request.operaUid;
  }
  if (!Util.isUnset(request.regionCode)) {
    body['RegionCode'] = request.regionCode;
  }
  if (!Util.isUnset(request.serviceName)) {
    body['ServiceName'] = request.serviceName;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetFunctionValidInfo',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getFunctionValidInfo(request: GetFunctionValidInfoRequest): GetFunctionValidInfoResponse {
  var runtime = new Util.RuntimeOptions{};
  return getFunctionValidInfoWithOptions(request, runtime);
}

model GetGroupByDimensionDataRequest {
  end?: long(name='End'),
  flag?: string(name='Flag'),
  groupBy?: string(name='GroupBy'),
  metricId?: string(name='MetricId'),
  operaUid?: string(name='OperaUid'),
  start?: long(name='Start'),
}

model GetGroupByDimensionDataResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  pageTotal?: long(name='PageTotal'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetGroupByDimensionDataResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetGroupByDimensionDataResponseBody(name='body'),
}

async function getGroupByDimensionDataWithOptions(request: GetGroupByDimensionDataRequest, runtime: Util.RuntimeOptions): GetGroupByDimensionDataResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.end)) {
    query['End'] = request.end;
  }
  if (!Util.isUnset(request.flag)) {
    query['Flag'] = request.flag;
  }
  if (!Util.isUnset(request.groupBy)) {
    query['GroupBy'] = request.groupBy;
  }
  if (!Util.isUnset(request.metricId)) {
    query['MetricId'] = request.metricId;
  }
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  if (!Util.isUnset(request.start)) {
    query['Start'] = request.start;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetGroupByDimensionData',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getGroupByDimensionData(request: GetGroupByDimensionDataRequest): GetGroupByDimensionDataResponse {
  var runtime = new Util.RuntimeOptions{};
  return getGroupByDimensionDataWithOptions(request, runtime);
}

model GetGroupResourceNumRequest {
  businessGroupId?: string(name='BusinessGroupId'),
  operaUid?: string(name='OperaUid'),
}

model GetGroupResourceNumResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetGroupResourceNumResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetGroupResourceNumResponseBody(name='body'),
}

async function getGroupResourceNumWithOptions(request: GetGroupResourceNumRequest, runtime: Util.RuntimeOptions): GetGroupResourceNumResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.businessGroupId)) {
    query['BusinessGroupId'] = request.businessGroupId;
  }
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetGroupResourceNum',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getGroupResourceNum(request: GetGroupResourceNumRequest): GetGroupResourceNumResponse {
  var runtime = new Util.RuntimeOptions{};
  return getGroupResourceNumWithOptions(request, runtime);
}

model GetGroupTopologyTagRequest {
  businessGroupId?: string(name='BusinessGroupId'),
  operaUid?: string(name='OperaUid'),
}

model GetGroupTopologyTagResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetGroupTopologyTagResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetGroupTopologyTagResponseBody(name='body'),
}

async function getGroupTopologyTagWithOptions(request: GetGroupTopologyTagRequest, runtime: Util.RuntimeOptions): GetGroupTopologyTagResponse {
  Util.validateModel(request);
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetGroupTopologyTag',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getGroupTopologyTag(request: GetGroupTopologyTagRequest): GetGroupTopologyTagResponse {
  var runtime = new Util.RuntimeOptions{};
  return getGroupTopologyTagWithOptions(request, runtime);
}

model GetIncidentAllRequest {
  operaUid?: string(name='OperaUid'),
}

model GetIncidentAllResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetIncidentAllResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetIncidentAllResponseBody(name='body'),
}

async function getIncidentAllWithOptions(request: GetIncidentAllRequest, runtime: Util.RuntimeOptions): GetIncidentAllResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetIncidentAll',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getIncidentAll(request: GetIncidentAllRequest): GetIncidentAllResponse {
  var runtime = new Util.RuntimeOptions{};
  return getIncidentAllWithOptions(request, runtime);
}

model GetIndexDialysisArrayRequest {
  businessGroupId?: string(name='BusinessGroupId'),
  cloudResourceId?: string(name='CloudResourceId'),
  cloudTypeName?: string(name='CloudTypeName'),
  currentPage?: int32(name='CurrentPage'),
  indexCode?: string(name='IndexCode'),
  operaUid?: string(name='OperaUid'),
  pageSize?: int32(name='PageSize'),
}

model GetIndexDialysisArrayResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  pageTotal?: long(name='PageTotal'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetIndexDialysisArrayResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetIndexDialysisArrayResponseBody(name='body'),
}

async function getIndexDialysisArrayWithOptions(request: GetIndexDialysisArrayRequest, runtime: Util.RuntimeOptions): GetIndexDialysisArrayResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.businessGroupId)) {
    query['BusinessGroupId'] = request.businessGroupId;
  }
  if (!Util.isUnset(request.cloudResourceId)) {
    query['CloudResourceId'] = request.cloudResourceId;
  }
  if (!Util.isUnset(request.cloudTypeName)) {
    query['CloudTypeName'] = request.cloudTypeName;
  }
  if (!Util.isUnset(request.currentPage)) {
    query['CurrentPage'] = request.currentPage;
  }
  if (!Util.isUnset(request.indexCode)) {
    query['IndexCode'] = request.indexCode;
  }
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetIndexDialysisArray',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getIndexDialysisArray(request: GetIndexDialysisArrayRequest): GetIndexDialysisArrayResponse {
  var runtime = new Util.RuntimeOptions{};
  return getIndexDialysisArrayWithOptions(request, runtime);
}

model GetIndexDialysisListRequest {
  businessGroupId?: string(name='BusinessGroupId'),
  cloudResourceId?: string(name='CloudResourceId'),
  cloudTypeName?: string(name='CloudTypeName'),
  currentPage?: int32(name='CurrentPage'),
  indexCode?: string(name='IndexCode'),
  operaUid?: string(name='OperaUid'),
  pageSize?: int32(name='PageSize'),
}

model GetIndexDialysisListResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  pageTotal?: long(name='PageTotal'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetIndexDialysisListResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetIndexDialysisListResponseBody(name='body'),
}

async function getIndexDialysisListWithOptions(request: GetIndexDialysisListRequest, runtime: Util.RuntimeOptions): GetIndexDialysisListResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.businessGroupId)) {
    query['BusinessGroupId'] = request.businessGroupId;
  }
  if (!Util.isUnset(request.cloudResourceId)) {
    query['CloudResourceId'] = request.cloudResourceId;
  }
  if (!Util.isUnset(request.cloudTypeName)) {
    query['CloudTypeName'] = request.cloudTypeName;
  }
  if (!Util.isUnset(request.currentPage)) {
    query['CurrentPage'] = request.currentPage;
  }
  if (!Util.isUnset(request.indexCode)) {
    query['IndexCode'] = request.indexCode;
  }
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetIndexDialysisList',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getIndexDialysisList(request: GetIndexDialysisListRequest): GetIndexDialysisListResponse {
  var runtime = new Util.RuntimeOptions{};
  return getIndexDialysisListWithOptions(request, runtime);
}

model GetIndexDialysisListLineRequest {
  beginTime?: long(name='BeginTime'),
  cloudResourceId?: string(name='CloudResourceId'),
  cloudTypeName?: string(name='CloudTypeName'),
  endTime?: long(name='EndTime'),
  indexCode?: string(name='IndexCode'),
  metricExtend?: string(name='MetricExtend'),
  operaUid?: string(name='OperaUid'),
}

model GetIndexDialysisListLineResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetIndexDialysisListLineResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetIndexDialysisListLineResponseBody(name='body'),
}

async function getIndexDialysisListLineWithOptions(request: GetIndexDialysisListLineRequest, runtime: Util.RuntimeOptions): GetIndexDialysisListLineResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.beginTime)) {
    query['BeginTime'] = request.beginTime;
  }
  if (!Util.isUnset(request.cloudResourceId)) {
    query['CloudResourceId'] = request.cloudResourceId;
  }
  if (!Util.isUnset(request.cloudTypeName)) {
    query['CloudTypeName'] = request.cloudTypeName;
  }
  if (!Util.isUnset(request.endTime)) {
    query['EndTime'] = request.endTime;
  }
  if (!Util.isUnset(request.indexCode)) {
    query['IndexCode'] = request.indexCode;
  }
  if (!Util.isUnset(request.metricExtend)) {
    query['MetricExtend'] = request.metricExtend;
  }
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetIndexDialysisListLine',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getIndexDialysisListLine(request: GetIndexDialysisListLineRequest): GetIndexDialysisListLineResponse {
  var runtime = new Util.RuntimeOptions{};
  return getIndexDialysisListLineWithOptions(request, runtime);
}

model GetInspectionReportDownloadUrlRequest {
  downloadReportListJson?: string(name='DownloadReportListJson'),
  operaUid?: string(name='OperaUid'),
}

model GetInspectionReportDownloadUrlResponseBody = {
  code?: int32(name='Code'),
  data?: string(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetInspectionReportDownloadUrlResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetInspectionReportDownloadUrlResponseBody(name='body'),
}

async function getInspectionReportDownloadUrlWithOptions(request: GetInspectionReportDownloadUrlRequest, runtime: Util.RuntimeOptions): GetInspectionReportDownloadUrlResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.downloadReportListJson)) {
    body['DownloadReportListJson'] = request.downloadReportListJson;
  }
  if (!Util.isUnset(request.operaUid)) {
    body['OperaUid'] = request.operaUid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetInspectionReportDownloadUrl',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getInspectionReportDownloadUrl(request: GetInspectionReportDownloadUrlRequest): GetInspectionReportDownloadUrlResponse {
  var runtime = new Util.RuntimeOptions{};
  return getInspectionReportDownloadUrlWithOptions(request, runtime);
}

model GetInstancesNumRequest {
  operaUid?: string(name='OperaUid'),
}

model GetInstancesNumResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetInstancesNumResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetInstancesNumResponseBody(name='body'),
}

async function getInstancesNumWithOptions(request: GetInstancesNumRequest, runtime: Util.RuntimeOptions): GetInstancesNumResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetInstancesNum',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getInstancesNum(request: GetInstancesNumRequest): GetInstancesNumResponse {
  var runtime = new Util.RuntimeOptions{};
  return getInstancesNumWithOptions(request, runtime);
}

model GetLogSampleRequest {
  appField?: string(name='AppField'),
  appValue?: string(name='AppValue'),
  dataSourceId?: long(name='DataSourceId'),
  logField?: string(name='LogField'),
  operaUid?: string(name='OperaUid'),
}

model GetLogSampleResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetLogSampleResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetLogSampleResponseBody(name='body'),
}

async function getLogSampleWithOptions(request: GetLogSampleRequest, runtime: Util.RuntimeOptions): GetLogSampleResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.appField)) {
    query['AppField'] = request.appField;
  }
  if (!Util.isUnset(request.appValue)) {
    query['AppValue'] = request.appValue;
  }
  if (!Util.isUnset(request.dataSourceId)) {
    query['DataSourceId'] = request.dataSourceId;
  }
  if (!Util.isUnset(request.logField)) {
    query['LogField'] = request.logField;
  }
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetLogSample',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getLogSample(request: GetLogSampleRequest): GetLogSampleResponse {
  var runtime = new Util.RuntimeOptions{};
  return getLogSampleWithOptions(request, runtime);
}

model GetLogSampleColumnRequest {
  dataSourceId?: long(name='DataSourceId'),
  operaUid?: string(name='OperaUid'),
}

model GetLogSampleColumnResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  pageTotal?: long(name='PageTotal'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetLogSampleColumnResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetLogSampleColumnResponseBody(name='body'),
}

async function getLogSampleColumnWithOptions(request: GetLogSampleColumnRequest, runtime: Util.RuntimeOptions): GetLogSampleColumnResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.dataSourceId)) {
    query['DataSourceId'] = request.dataSourceId;
  }
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetLogSampleColumn',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getLogSampleColumn(request: GetLogSampleColumnRequest): GetLogSampleColumnResponse {
  var runtime = new Util.RuntimeOptions{};
  return getLogSampleColumnWithOptions(request, runtime);
}

model GetMetricEventSequentialTrentRequest {
  aliUid?: string(name='AliUid'),
  eventId?: string(name='EventId'),
  operaUid?: string(name='OperaUid'),
}

model GetMetricEventSequentialTrentResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  message?: string(name='Message'),
  pageTotal?: int32(name='PageTotal'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetMetricEventSequentialTrentResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetMetricEventSequentialTrentResponseBody(name='body'),
}

async function getMetricEventSequentialTrentWithOptions(request: GetMetricEventSequentialTrentRequest, runtime: Util.RuntimeOptions): GetMetricEventSequentialTrentResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.aliUid)) {
    query['AliUid'] = request.aliUid;
  }
  if (!Util.isUnset(request.eventId)) {
    query['EventId'] = request.eventId;
  }
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetMetricEventSequentialTrent',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getMetricEventSequentialTrent(request: GetMetricEventSequentialTrentRequest): GetMetricEventSequentialTrentResponse {
  var runtime = new Util.RuntimeOptions{};
  return getMetricEventSequentialTrentWithOptions(request, runtime);
}

model GetNewOptimizationItemDataRequest {
  lang?: string(name='Lang'),
  operaUid?: string(name='OperaUid'),
}

model GetNewOptimizationItemDataResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetNewOptimizationItemDataResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetNewOptimizationItemDataResponseBody(name='body'),
}

async function getNewOptimizationItemDataWithOptions(request: GetNewOptimizationItemDataRequest, runtime: Util.RuntimeOptions): GetNewOptimizationItemDataResponse {
  Util.validateModel(request);
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetNewOptimizationItemData',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getNewOptimizationItemData(request: GetNewOptimizationItemDataRequest): GetNewOptimizationItemDataResponse {
  var runtime = new Util.RuntimeOptions{};
  return getNewOptimizationItemDataWithOptions(request, runtime);
}

model GetPatrolInspectionDetailListRequest {
  currentPage?: int32(name='CurrentPage'),
  instanceId?: string(name='InstanceId'),
  instanceName?: string(name='InstanceName'),
  operaUid?: string(name='OperaUid'),
  pageSize?: int32(name='PageSize'),
  patrolId?: long(name='PatrolId'),
  status?: int32(name='Status'),
}

model GetPatrolInspectionDetailListResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  pageTotal?: long(name='PageTotal'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetPatrolInspectionDetailListResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetPatrolInspectionDetailListResponseBody(name='body'),
}

async function getPatrolInspectionDetailListWithOptions(request: GetPatrolInspectionDetailListRequest, runtime: Util.RuntimeOptions): GetPatrolInspectionDetailListResponse {
  Util.validateModel(request);
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetPatrolInspectionDetailList',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getPatrolInspectionDetailList(request: GetPatrolInspectionDetailListRequest): GetPatrolInspectionDetailListResponse {
  var runtime = new Util.RuntimeOptions{};
  return getPatrolInspectionDetailListWithOptions(request, runtime);
}

model GetPatrolInspectionDetailThrendDataRequest {
  endTime?: long(name='EndTime'),
  operaUid?: string(name='OperaUid'),
  requestContent?: string(name='RequestContent'),
  startTime?: long(name='StartTime'),
}

model GetPatrolInspectionDetailThrendDataResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetPatrolInspectionDetailThrendDataResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetPatrolInspectionDetailThrendDataResponseBody(name='body'),
}

async function getPatrolInspectionDetailThrendDataWithOptions(request: GetPatrolInspectionDetailThrendDataRequest, runtime: Util.RuntimeOptions): GetPatrolInspectionDetailThrendDataResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.endTime)) {
    query['EndTime'] = request.endTime;
  }
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  if (!Util.isUnset(request.requestContent)) {
    query['RequestContent'] = request.requestContent;
  }
  if (!Util.isUnset(request.startTime)) {
    query['StartTime'] = request.startTime;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetPatrolInspectionDetailThrendData',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getPatrolInspectionDetailThrendData(request: GetPatrolInspectionDetailThrendDataRequest): GetPatrolInspectionDetailThrendDataResponse {
  var runtime = new Util.RuntimeOptions{};
  return getPatrolInspectionDetailThrendDataWithOptions(request, runtime);
}

model GetPatrolInspectionItemsListRequest {
  operaUid?: string(name='OperaUid'),
}

model GetPatrolInspectionItemsListResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetPatrolInspectionItemsListResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetPatrolInspectionItemsListResponseBody(name='body'),
}

async function getPatrolInspectionItemsListWithOptions(request: GetPatrolInspectionItemsListRequest, runtime: Util.RuntimeOptions): GetPatrolInspectionItemsListResponse {
  Util.validateModel(request);
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetPatrolInspectionItemsList',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getPatrolInspectionItemsList(request: GetPatrolInspectionItemsListRequest): GetPatrolInspectionItemsListResponse {
  var runtime = new Util.RuntimeOptions{};
  return getPatrolInspectionItemsListWithOptions(request, runtime);
}

model GetPatrolInspectionListRequest {
  businessGroupId?: string(name='BusinessGroupId'),
  currentPage?: int32(name='CurrentPage'),
  lang?: string(name='Lang'),
  operaUid?: string(name='OperaUid'),
  pageSize?: int32(name='PageSize'),
  patrolId?: long(name='PatrolId'),
  productCode?: string(name='ProductCode'),
  riskLevel?: int32(name='RiskLevel'),
  riskName?: string(name='RiskName'),
  riskPatrolItem?: string(name='RiskPatrolItem'),
  riskType?: int32(name='RiskType'),
  severityLevel?: int32(name='SeverityLevel'),
  status?: int32(name='Status'),
}

model GetPatrolInspectionListResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  pageTotal?: long(name='PageTotal'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetPatrolInspectionListResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetPatrolInspectionListResponseBody(name='body'),
}

async function getPatrolInspectionListWithOptions(request: GetPatrolInspectionListRequest, runtime: Util.RuntimeOptions): GetPatrolInspectionListResponse {
  Util.validateModel(request);
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetPatrolInspectionList',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getPatrolInspectionList(request: GetPatrolInspectionListRequest): GetPatrolInspectionListResponse {
  var runtime = new Util.RuntimeOptions{};
  return getPatrolInspectionListWithOptions(request, runtime);
}

model GetPatrolInspectionStatusRequest {
  operaUid?: string(name='OperaUid'),
}

model GetPatrolInspectionStatusResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetPatrolInspectionStatusResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetPatrolInspectionStatusResponseBody(name='body'),
}

async function getPatrolInspectionStatusWithOptions(request: GetPatrolInspectionStatusRequest, runtime: Util.RuntimeOptions): GetPatrolInspectionStatusResponse {
  Util.validateModel(request);
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetPatrolInspectionStatus',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getPatrolInspectionStatus(request: GetPatrolInspectionStatusRequest): GetPatrolInspectionStatusResponse {
  var runtime = new Util.RuntimeOptions{};
  return getPatrolInspectionStatusWithOptions(request, runtime);
}

model GetProductInstanceRequest {
  instanceId?: string(name='InstanceId'),
  operaUid?: string(name='OperaUid'),
  productCode?: string(name='ProductCode'),
}

model GetProductInstanceResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetProductInstanceResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetProductInstanceResponseBody(name='body'),
}

async function getProductInstanceWithOptions(request: GetProductInstanceRequest, runtime: Util.RuntimeOptions): GetProductInstanceResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.instanceId)) {
    query['InstanceId'] = request.instanceId;
  }
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  if (!Util.isUnset(request.productCode)) {
    query['ProductCode'] = request.productCode;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetProductInstance',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getProductInstance(request: GetProductInstanceRequest): GetProductInstanceResponse {
  var runtime = new Util.RuntimeOptions{};
  return getProductInstanceWithOptions(request, runtime);
}

model GetProductMetricListResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetProductMetricListResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetProductMetricListResponseBody(name='body'),
}

async function getProductMetricListWithOptions(runtime: Util.RuntimeOptions): GetProductMetricListResponse {
  var req = new OpenApi.OpenApiRequest{};
  var params = new OpenApi.Params{
    action = 'GetProductMetricList',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getProductMetricList(): GetProductMetricListResponse {
  var runtime = new Util.RuntimeOptions{};
  return getProductMetricListWithOptions(runtime);
}

model GetRealDataRequest {
  endTimestamp?: string(name='EndTimestamp'),
  flowName?: string(name='FlowName'),
  instanceId?: string(name='InstanceId'),
  startTimestamp?: string(name='StartTimestamp'),
  uid?: long(name='Uid'),
}

model GetRealDataResponseBody = {
  code?: long(name='Code'),
  data?: map[string]any(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetRealDataResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetRealDataResponseBody(name='body'),
}

async function getRealDataWithOptions(request: GetRealDataRequest, runtime: Util.RuntimeOptions): GetRealDataResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.endTimestamp)) {
    query['EndTimestamp'] = request.endTimestamp;
  }
  if (!Util.isUnset(request.flowName)) {
    query['FlowName'] = request.flowName;
  }
  if (!Util.isUnset(request.instanceId)) {
    query['InstanceId'] = request.instanceId;
  }
  if (!Util.isUnset(request.startTimestamp)) {
    query['StartTimestamp'] = request.startTimestamp;
  }
  if (!Util.isUnset(request.uid)) {
    query['Uid'] = request.uid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetRealData',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getRealData(request: GetRealDataRequest): GetRealDataResponse {
  var runtime = new Util.RuntimeOptions{};
  return getRealDataWithOptions(request, runtime);
}

model GetRegionListResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: boolean(name='Status'),
}

model GetRegionListResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetRegionListResponseBody(name='body'),
}

async function getRegionListWithOptions(runtime: Util.RuntimeOptions): GetRegionListResponse {
  var req = new OpenApi.OpenApiRequest{};
  var params = new OpenApi.Params{
    action = 'GetRegionList',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getRegionList(): GetRegionListResponse {
  var runtime = new Util.RuntimeOptions{};
  return getRegionListWithOptions(runtime);
}

model GetRepairScriptRequest {
  eventId?: string(name='EventId'),
  operaUid?: string(name='OperaUid'),
}

model GetRepairScriptResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetRepairScriptResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetRepairScriptResponseBody(name='body'),
}

async function getRepairScriptWithOptions(request: GetRepairScriptRequest, runtime: Util.RuntimeOptions): GetRepairScriptResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.eventId)) {
    query['EventId'] = request.eventId;
  }
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetRepairScript',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getRepairScript(request: GetRepairScriptRequest): GetRepairScriptResponse {
  var runtime = new Util.RuntimeOptions{};
  return getRepairScriptWithOptions(request, runtime);
}

model GetResourceListRequest {
  operaUid?: string(name='OperaUid'),
}

model GetResourceListResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetResourceListResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetResourceListResponseBody(name='body'),
}

async function getResourceListWithOptions(request: GetResourceListRequest, runtime: Util.RuntimeOptions): GetResourceListResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetResourceList',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getResourceList(request: GetResourceListRequest): GetResourceListResponse {
  var runtime = new Util.RuntimeOptions{};
  return getResourceListWithOptions(request, runtime);
}

model GetResourceTagDropListRequest {
  businessGroupId?: string(name='BusinessGroupId'),
  operaUid?: string(name='OperaUid'),
}

model GetResourceTagDropListResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetResourceTagDropListResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetResourceTagDropListResponseBody(name='body'),
}

async function getResourceTagDropListWithOptions(request: GetResourceTagDropListRequest, runtime: Util.RuntimeOptions): GetResourceTagDropListResponse {
  Util.validateModel(request);
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetResourceTagDropList',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getResourceTagDropList(request: GetResourceTagDropListRequest): GetResourceTagDropListResponse {
  var runtime = new Util.RuntimeOptions{};
  return getResourceTagDropListWithOptions(request, runtime);
}

model GetResourceTypeListResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: boolean(name='Status'),
}

model GetResourceTypeListResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetResourceTypeListResponseBody(name='body'),
}

async function getResourceTypeListWithOptions(runtime: Util.RuntimeOptions): GetResourceTypeListResponse {
  var req = new OpenApi.OpenApiRequest{};
  var params = new OpenApi.Params{
    action = 'GetResourceTypeList',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getResourceTypeList(): GetResourceTypeListResponse {
  var runtime = new Util.RuntimeOptions{};
  return getResourceTypeListWithOptions(runtime);
}

model GetRiskInAllRequest {
  operaUid?: string(name='OperaUid'),
  screen?: int32(name='Screen'),
}

model GetRiskInAllResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  pageTotal?: long(name='PageTotal'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetRiskInAllResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetRiskInAllResponseBody(name='body'),
}

async function getRiskInAllWithOptions(request: GetRiskInAllRequest, runtime: Util.RuntimeOptions): GetRiskInAllResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  if (!Util.isUnset(request.screen)) {
    query['Screen'] = request.screen;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetRiskInAll',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getRiskInAll(request: GetRiskInAllRequest): GetRiskInAllResponse {
  var runtime = new Util.RuntimeOptions{};
  return getRiskInAllWithOptions(request, runtime);
}

model GetRiskInspectStatisticsRequest {
  operaUid?: string(name='OperaUid'),
}

model GetRiskInspectStatisticsResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetRiskInspectStatisticsResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetRiskInspectStatisticsResponseBody(name='body'),
}

async function getRiskInspectStatisticsWithOptions(request: GetRiskInspectStatisticsRequest, runtime: Util.RuntimeOptions): GetRiskInspectStatisticsResponse {
  Util.validateModel(request);
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetRiskInspectStatistics',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getRiskInspectStatistics(request: GetRiskInspectStatisticsRequest): GetRiskInspectStatisticsResponse {
  var runtime = new Util.RuntimeOptions{};
  return getRiskInspectStatisticsWithOptions(request, runtime);
}

model GetRiskInspectionTypeListRequest {
  operaUid?: string(name='OperaUid'),
}

model GetRiskInspectionTypeListResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetRiskInspectionTypeListResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetRiskInspectionTypeListResponseBody(name='body'),
}

async function getRiskInspectionTypeListWithOptions(request: GetRiskInspectionTypeListRequest, runtime: Util.RuntimeOptions): GetRiskInspectionTypeListResponse {
  Util.validateModel(request);
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetRiskInspectionTypeList',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getRiskInspectionTypeList(request: GetRiskInspectionTypeListRequest): GetRiskInspectionTypeListResponse {
  var runtime = new Util.RuntimeOptions{};
  return getRiskInspectionTypeListWithOptions(request, runtime);
}

model GetRiskPatrolDetailListRequest {
  currentPage?: int32(name='CurrentPage'),
  instanceId?: string(name='InstanceId'),
  instanceName?: string(name='InstanceName'),
  operaUid?: string(name='OperaUid'),
  pageSize?: int32(name='PageSize'),
  patrolId?: long(name='PatrolId'),
  status?: int32(name='Status'),
}

model GetRiskPatrolDetailListResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  pageTotal?: long(name='PageTotal'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetRiskPatrolDetailListResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetRiskPatrolDetailListResponseBody(name='body'),
}

async function getRiskPatrolDetailListWithOptions(request: GetRiskPatrolDetailListRequest, runtime: Util.RuntimeOptions): GetRiskPatrolDetailListResponse {
  Util.validateModel(request);
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetRiskPatrolDetailList',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getRiskPatrolDetailList(request: GetRiskPatrolDetailListRequest): GetRiskPatrolDetailListResponse {
  var runtime = new Util.RuntimeOptions{};
  return getRiskPatrolDetailListWithOptions(request, runtime);
}

model GetRiskPatrolListRequest {
  businessGroupId?: string(name='BusinessGroupId'),
  businessGroupName?: string(name='BusinessGroupName'),
  currentPage?: int32(name='CurrentPage'),
  operaUid?: string(name='OperaUid'),
  pageSize?: int32(name='PageSize'),
  patrolId?: long(name='PatrolId'),
  riskPatrolItem?: string(name='RiskPatrolItem'),
  severityLevel?: int32(name='SeverityLevel'),
  status?: int32(name='Status'),
}

model GetRiskPatrolListResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  pageTotal?: long(name='PageTotal'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetRiskPatrolListResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetRiskPatrolListResponseBody(name='body'),
}

async function getRiskPatrolListWithOptions(request: GetRiskPatrolListRequest, runtime: Util.RuntimeOptions): GetRiskPatrolListResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.businessGroupId)) {
    query['BusinessGroupId'] = request.businessGroupId;
  }
  if (!Util.isUnset(request.businessGroupName)) {
    query['BusinessGroupName'] = request.businessGroupName;
  }
  if (!Util.isUnset(request.currentPage)) {
    query['CurrentPage'] = request.currentPage;
  }
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.patrolId)) {
    query['PatrolId'] = request.patrolId;
  }
  if (!Util.isUnset(request.riskPatrolItem)) {
    query['RiskPatrolItem'] = request.riskPatrolItem;
  }
  if (!Util.isUnset(request.severityLevel)) {
    query['SeverityLevel'] = request.severityLevel;
  }
  if (!Util.isUnset(request.status)) {
    query['Status'] = request.status;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetRiskPatrolList',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getRiskPatrolList(request: GetRiskPatrolListRequest): GetRiskPatrolListResponse {
  var runtime = new Util.RuntimeOptions{};
  return getRiskPatrolListWithOptions(request, runtime);
}

model GetRiskPatrolStatisticalTrendsRequest {
  eventId?: string(name='EventId'),
  lang?: string(name='Lang'),
  operaUid?: string(name='OperaUid'),
}

model GetRiskPatrolStatisticalTrendsResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetRiskPatrolStatisticalTrendsResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetRiskPatrolStatisticalTrendsResponseBody(name='body'),
}

async function getRiskPatrolStatisticalTrendsWithOptions(request: GetRiskPatrolStatisticalTrendsRequest, runtime: Util.RuntimeOptions): GetRiskPatrolStatisticalTrendsResponse {
  Util.validateModel(request);
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetRiskPatrolStatisticalTrends',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getRiskPatrolStatisticalTrends(request: GetRiskPatrolStatisticalTrendsRequest): GetRiskPatrolStatisticalTrendsResponse {
  var runtime = new Util.RuntimeOptions{};
  return getRiskPatrolStatisticalTrendsWithOptions(request, runtime);
}

model GetRiskPatrolStatisticsRequest {
  operaUid?: string(name='OperaUid'),
}

model GetRiskPatrolStatisticsResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetRiskPatrolStatisticsResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetRiskPatrolStatisticsResponseBody(name='body'),
}

async function getRiskPatrolStatisticsWithOptions(request: GetRiskPatrolStatisticsRequest, runtime: Util.RuntimeOptions): GetRiskPatrolStatisticsResponse {
  Util.validateModel(request);
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetRiskPatrolStatistics',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getRiskPatrolStatistics(request: GetRiskPatrolStatisticsRequest): GetRiskPatrolStatisticsResponse {
  var runtime = new Util.RuntimeOptions{};
  return getRiskPatrolStatisticsWithOptions(request, runtime);
}

model GetRiskPatrolStatusRequest {
  operaUid?: string(name='OperaUid'),
}

model GetRiskPatrolStatusResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetRiskPatrolStatusResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetRiskPatrolStatusResponseBody(name='body'),
}

async function getRiskPatrolStatusWithOptions(request: GetRiskPatrolStatusRequest, runtime: Util.RuntimeOptions): GetRiskPatrolStatusResponse {
  Util.validateModel(request);
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetRiskPatrolStatus',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getRiskPatrolStatus(request: GetRiskPatrolStatusRequest): GetRiskPatrolStatusResponse {
  var runtime = new Util.RuntimeOptions{};
  return getRiskPatrolStatusWithOptions(request, runtime);
}

model GetRoleResponseBody = {
  code?: int32(name='Code'),
  data?: boolean(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  staus?: string(name='Staus'),
}

model GetRoleResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetRoleResponseBody(name='body'),
}

async function getRoleWithOptions(runtime: Util.RuntimeOptions): GetRoleResponse {
  var req = new OpenApi.OpenApiRequest{};
  var params = new OpenApi.Params{
    action = 'GetRole',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getRole(): GetRoleResponse {
  var runtime = new Util.RuntimeOptions{};
  return getRoleWithOptions(runtime);
}

model GetRootCauseRequest {
  eventId?: string(name='EventId'),
  instanceId?: string(name='InstanceId'),
  rootCauseId?: string(name='RootCauseId'),
}

model GetRootCauseResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetRootCauseResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetRootCauseResponseBody(name='body'),
}

async function getRootCauseWithOptions(request: GetRootCauseRequest, runtime: Util.RuntimeOptions): GetRootCauseResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.eventId)) {
    query['EventId'] = request.eventId;
  }
  if (!Util.isUnset(request.instanceId)) {
    query['InstanceId'] = request.instanceId;
  }
  if (!Util.isUnset(request.rootCauseId)) {
    query['RootCauseId'] = request.rootCauseId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetRootCause',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getRootCause(request: GetRootCauseRequest): GetRootCauseResponse {
  var runtime = new Util.RuntimeOptions{};
  return getRootCauseWithOptions(request, runtime);
}

model GetScenarioDetailRequest {
  id?: string(name='Id'),
  operaUid?: string(name='OperaUid'),
}

model GetScenarioDetailResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  pageTotal?: long(name='PageTotal'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetScenarioDetailResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetScenarioDetailResponseBody(name='body'),
}

async function getScenarioDetailWithOptions(request: GetScenarioDetailRequest, runtime: Util.RuntimeOptions): GetScenarioDetailResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.id)) {
    query['Id'] = request.id;
  }
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetScenarioDetail',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getScenarioDetail(request: GetScenarioDetailRequest): GetScenarioDetailResponse {
  var runtime = new Util.RuntimeOptions{};
  return getScenarioDetailWithOptions(request, runtime);
}

model GetScenarioListRequest {
  operaUid?: string(name='OperaUid'),
  pageNo?: long(name='PageNo'),
  pageSize?: long(name='PageSize'),
  scenarioName?: string(name='ScenarioName'),
  sceneSelectLabel?: string(name='SceneSelectLabel'),
}

model GetScenarioListResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  pageTotal?: long(name='PageTotal'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetScenarioListResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetScenarioListResponseBody(name='body'),
}

async function getScenarioListWithOptions(request: GetScenarioListRequest, runtime: Util.RuntimeOptions): GetScenarioListResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  if (!Util.isUnset(request.pageNo)) {
    query['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.scenarioName)) {
    query['ScenarioName'] = request.scenarioName;
  }
  if (!Util.isUnset(request.sceneSelectLabel)) {
    query['SceneSelectLabel'] = request.sceneSelectLabel;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetScenarioList',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getScenarioList(request: GetScenarioListRequest): GetScenarioListResponse {
  var runtime = new Util.RuntimeOptions{};
  return getScenarioListWithOptions(request, runtime);
}

model GetScenarioStatisticsListRequest {
  endTime?: long(name='EndTime'),
  operaUid?: string(name='OperaUid'),
  scenarioIds?: string(name='ScenarioIds'),
}

model GetScenarioStatisticsListResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  pageTotal?: long(name='PageTotal'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetScenarioStatisticsListResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetScenarioStatisticsListResponseBody(name='body'),
}

async function getScenarioStatisticsListWithOptions(request: GetScenarioStatisticsListRequest, runtime: Util.RuntimeOptions): GetScenarioStatisticsListResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.endTime)) {
    query['EndTime'] = request.endTime;
  }
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  if (!Util.isUnset(request.scenarioIds)) {
    query['ScenarioIds'] = request.scenarioIds;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetScenarioStatisticsList',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getScenarioStatisticsList(request: GetScenarioStatisticsListRequest): GetScenarioStatisticsListResponse {
  var runtime = new Util.RuntimeOptions{};
  return getScenarioStatisticsListWithOptions(request, runtime);
}

model GetSceneByIdRequest {
  id?: int32(name='Id'),
  metricId?: int32(name='MetricId'),
  operaUid?: string(name='OperaUid'),
}

model GetSceneByIdResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]int32(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetSceneByIdResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetSceneByIdResponseBody(name='body'),
}

async function getSceneByIdWithOptions(request: GetSceneByIdRequest, runtime: Util.RuntimeOptions): GetSceneByIdResponse {
  Util.validateModel(request);
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetSceneById',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getSceneById(request: GetSceneByIdRequest): GetSceneByIdResponse {
  var runtime = new Util.RuntimeOptions{};
  return getSceneByIdWithOptions(request, runtime);
}

model GetSceneDetailsListRequest {
  id?: int32(name='Id'),
  operaUid?: string(name='OperaUid'),
}

model GetSceneDetailsListResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]int32(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetSceneDetailsListResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetSceneDetailsListResponseBody(name='body'),
}

async function getSceneDetailsListWithOptions(request: GetSceneDetailsListRequest, runtime: Util.RuntimeOptions): GetSceneDetailsListResponse {
  Util.validateModel(request);
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetSceneDetailsList',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getSceneDetailsList(request: GetSceneDetailsListRequest): GetSceneDetailsListResponse {
  var runtime = new Util.RuntimeOptions{};
  return getSceneDetailsListWithOptions(request, runtime);
}

model GetSceneListRequest {
  operaUid?: string(name='OperaUid'),
  pageNum?: int32(name='PageNum'),
  pageSize?: int32(name='PageSize'),
  pageTotal?: int32(name='PageTotal'),
  sceneType?: string(name='SceneType'),
  searchName?: string(name='SearchName'),
  searchValue?: string(name='SearchValue'),
  status?: int32(name='Status'),
}

model GetSceneListResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]int32(name='Data'),
  msg?: string(name='Msg'),
  pageTotal?: int32(name='PageTotal'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetSceneListResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetSceneListResponseBody(name='body'),
}

async function getSceneListWithOptions(request: GetSceneListRequest, runtime: Util.RuntimeOptions): GetSceneListResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  if (!Util.isUnset(request.pageNum)) {
    query['PageNum'] = request.pageNum;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.pageTotal)) {
    query['PageTotal'] = request.pageTotal;
  }
  if (!Util.isUnset(request.sceneType)) {
    query['SceneType'] = request.sceneType;
  }
  if (!Util.isUnset(request.searchName)) {
    query['SearchName'] = request.searchName;
  }
  if (!Util.isUnset(request.searchValue)) {
    query['SearchValue'] = request.searchValue;
  }
  if (!Util.isUnset(request.status)) {
    query['Status'] = request.status;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetSceneList',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getSceneList(request: GetSceneListRequest): GetSceneListResponse {
  var runtime = new Util.RuntimeOptions{};
  return getSceneListWithOptions(request, runtime);
}

model GetSceneMetricTableRequest {
  end?: long(name='End'),
  metricId?: string(name='MetricId'),
  operaUid?: string(name='OperaUid'),
  start?: long(name='Start'),
}

model GetSceneMetricTableResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  pageTotal?: long(name='PageTotal'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetSceneMetricTableResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetSceneMetricTableResponseBody(name='body'),
}

async function getSceneMetricTableWithOptions(request: GetSceneMetricTableRequest, runtime: Util.RuntimeOptions): GetSceneMetricTableResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.end)) {
    query['End'] = request.end;
  }
  if (!Util.isUnset(request.metricId)) {
    query['MetricId'] = request.metricId;
  }
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  if (!Util.isUnset(request.start)) {
    query['Start'] = request.start;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetSceneMetricTable',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getSceneMetricTable(request: GetSceneMetricTableRequest): GetSceneMetricTableResponse {
  var runtime = new Util.RuntimeOptions{};
  return getSceneMetricTableWithOptions(request, runtime);
}

model GetScriptEventRootCauseRequest {
  eventId?: string(name='EventId'),
  operaUid?: string(name='OperaUid'),
}

model GetScriptEventRootCauseResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetScriptEventRootCauseResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetScriptEventRootCauseResponseBody(name='body'),
}

async function getScriptEventRootCauseWithOptions(request: GetScriptEventRootCauseRequest, runtime: Util.RuntimeOptions): GetScriptEventRootCauseResponse {
  Util.validateModel(request);
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetScriptEventRootCause',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getScriptEventRootCause(request: GetScriptEventRootCauseRequest): GetScriptEventRootCauseResponse {
  var runtime = new Util.RuntimeOptions{};
  return getScriptEventRootCauseWithOptions(request, runtime);
}

model GetSlsLogDataRequest {
  code?: string(name='Code'),
  domain?: string(name='Domain'),
  endTime?: long(name='EndTime'),
  operaUid?: string(name='OperaUid'),
  startTime?: long(name='StartTime'),
  url?: string(name='Url'),
}

model GetSlsLogDataResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetSlsLogDataResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetSlsLogDataResponseBody(name='body'),
}

async function getSlsLogDataWithOptions(request: GetSlsLogDataRequest, runtime: Util.RuntimeOptions): GetSlsLogDataResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.code)) {
    query['Code'] = request.code;
  }
  if (!Util.isUnset(request.domain)) {
    query['Domain'] = request.domain;
  }
  if (!Util.isUnset(request.endTime)) {
    query['EndTime'] = request.endTime;
  }
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  if (!Util.isUnset(request.startTime)) {
    query['StartTime'] = request.startTime;
  }
  if (!Util.isUnset(request.url)) {
    query['Url'] = request.url;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetSlsLogData',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getSlsLogData(request: GetSlsLogDataRequest): GetSlsLogDataResponse {
  var runtime = new Util.RuntimeOptions{};
  return getSlsLogDataWithOptions(request, runtime);
}

model GetSynCloudResourceListRequest {
  operaUid?: string(name='OperaUid'),
}

model GetSynCloudResourceListResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  pageTotal?: int32(name='PageTotal'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetSynCloudResourceListResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetSynCloudResourceListResponseBody(name='body'),
}

async function getSynCloudResourceListWithOptions(request: GetSynCloudResourceListRequest, runtime: Util.RuntimeOptions): GetSynCloudResourceListResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetSynCloudResourceList',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getSynCloudResourceList(request: GetSynCloudResourceListRequest): GetSynCloudResourceListResponse {
  var runtime = new Util.RuntimeOptions{};
  return getSynCloudResourceListWithOptions(request, runtime);
}

model GetTagBusinessGroupListRequest {
  operaUid?: string(name='OperaUid'),
  tagId?: long(name='TagId'),
}

model GetTagBusinessGroupListResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetTagBusinessGroupListResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetTagBusinessGroupListResponseBody(name='body'),
}

async function getTagBusinessGroupListWithOptions(request: GetTagBusinessGroupListRequest, runtime: Util.RuntimeOptions): GetTagBusinessGroupListResponse {
  Util.validateModel(request);
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetTagBusinessGroupList',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getTagBusinessGroupList(request: GetTagBusinessGroupListRequest): GetTagBusinessGroupListResponse {
  var runtime = new Util.RuntimeOptions{};
  return getTagBusinessGroupListWithOptions(request, runtime);
}

model GetTagDropListRequest {
  operaUid?: string(name='OperaUid'),
  productId?: long(name='ProductId'),
}

model GetTagDropListResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetTagDropListResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetTagDropListResponseBody(name='body'),
}

async function getTagDropListWithOptions(request: GetTagDropListRequest, runtime: Util.RuntimeOptions): GetTagDropListResponse {
  Util.validateModel(request);
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetTagDropList',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getTagDropList(request: GetTagDropListRequest): GetTagDropListResponse {
  var runtime = new Util.RuntimeOptions{};
  return getTagDropListWithOptions(request, runtime);
}

model GetTargetDimensionDataRequest {
  end?: long(name='End'),
  flag?: string(name='Flag'),
  label?: string(name='Label'),
  labelValue?: string(name='LabelValue'),
  metricId?: string(name='MetricId'),
  operaUid?: string(name='OperaUid'),
  start?: long(name='Start'),
}

model GetTargetDimensionDataResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  pageTotal?: long(name='PageTotal'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetTargetDimensionDataResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetTargetDimensionDataResponseBody(name='body'),
}

async function getTargetDimensionDataWithOptions(request: GetTargetDimensionDataRequest, runtime: Util.RuntimeOptions): GetTargetDimensionDataResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.end)) {
    query['End'] = request.end;
  }
  if (!Util.isUnset(request.flag)) {
    query['Flag'] = request.flag;
  }
  if (!Util.isUnset(request.label)) {
    query['Label'] = request.label;
  }
  if (!Util.isUnset(request.labelValue)) {
    query['LabelValue'] = request.labelValue;
  }
  if (!Util.isUnset(request.metricId)) {
    query['MetricId'] = request.metricId;
  }
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  if (!Util.isUnset(request.start)) {
    query['Start'] = request.start;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetTargetDimensionData',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getTargetDimensionData(request: GetTargetDimensionDataRequest): GetTargetDimensionDataResponse {
  var runtime = new Util.RuntimeOptions{};
  return getTargetDimensionDataWithOptions(request, runtime);
}

model GetThresholdListRequest {
  operaUid?: string(name='OperaUid'),
}

model GetThresholdListResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetThresholdListResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetThresholdListResponseBody(name='body'),
}

async function getThresholdListWithOptions(request: GetThresholdListRequest, runtime: Util.RuntimeOptions): GetThresholdListResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetThresholdList',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getThresholdList(request: GetThresholdListRequest): GetThresholdListResponse {
  var runtime = new Util.RuntimeOptions{};
  return getThresholdListWithOptions(request, runtime);
}

model GetThroughPutRequest {
  operaUid?: string(name='OperaUid'),
}

model GetThroughPutResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetThroughPutResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetThroughPutResponseBody(name='body'),
}

async function getThroughPutWithOptions(request: GetThroughPutRequest, runtime: Util.RuntimeOptions): GetThroughPutResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetThroughPut',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getThroughPut(request: GetThroughPutRequest): GetThroughPutResponse {
  var runtime = new Util.RuntimeOptions{};
  return getThroughPutWithOptions(request, runtime);
}

model GetTrendSlsReportsRequest {
  instanceId?: string(name='InstanceId'),
  productCode?: string(name='ProductCode'),
  severity?: string(name='Severity'),
  uid?: long(name='Uid'),
}

model GetTrendSlsReportsResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetTrendSlsReportsResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetTrendSlsReportsResponseBody(name='body'),
}

async function getTrendSlsReportsWithOptions(request: GetTrendSlsReportsRequest, runtime: Util.RuntimeOptions): GetTrendSlsReportsResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.instanceId)) {
    query['InstanceId'] = request.instanceId;
  }
  if (!Util.isUnset(request.productCode)) {
    query['ProductCode'] = request.productCode;
  }
  if (!Util.isUnset(request.severity)) {
    query['Severity'] = request.severity;
  }
  if (!Util.isUnset(request.uid)) {
    query['Uid'] = request.uid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetTrendSlsReports',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getTrendSlsReports(request: GetTrendSlsReportsRequest): GetTrendSlsReportsResponse {
  var runtime = new Util.RuntimeOptions{};
  return getTrendSlsReportsWithOptions(request, runtime);
}

model GetUserInfoRequest {
  operaUid?: string(name='OperaUid'),
}

model GetUserInfoResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetUserInfoResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetUserInfoResponseBody(name='body'),
}

async function getUserInfoWithOptions(request: GetUserInfoRequest, runtime: Util.RuntimeOptions): GetUserInfoResponse {
  Util.validateModel(request);
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetUserInfo',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getUserInfo(request: GetUserInfoRequest): GetUserInfoResponse {
  var runtime = new Util.RuntimeOptions{};
  return getUserInfoWithOptions(request, runtime);
}

model GetUserLoginInfoRequest {
  accountName?: string(name='AccountName'),
  accountPrincipalName?: string(name='AccountPrincipalName'),
  accountType?: string(name='AccountType'),
  currentPk?: string(name='CurrentPk'),
  mainAccountPk?: string(name='MainAccountPk'),
}

model GetUserLoginInfoResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetUserLoginInfoResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetUserLoginInfoResponseBody(name='body'),
}

async function getUserLoginInfoWithOptions(request: GetUserLoginInfoRequest, runtime: Util.RuntimeOptions): GetUserLoginInfoResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.accountName)) {
    query['AccountName'] = request.accountName;
  }
  if (!Util.isUnset(request.accountPrincipalName)) {
    query['AccountPrincipalName'] = request.accountPrincipalName;
  }
  if (!Util.isUnset(request.accountType)) {
    query['AccountType'] = request.accountType;
  }
  if (!Util.isUnset(request.currentPk)) {
    query['CurrentPk'] = request.currentPk;
  }
  if (!Util.isUnset(request.mainAccountPk)) {
    query['MainAccountPk'] = request.mainAccountPk;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetUserLoginInfo',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getUserLoginInfo(request: GetUserLoginInfoRequest): GetUserLoginInfoResponse {
  var runtime = new Util.RuntimeOptions{};
  return getUserLoginInfoWithOptions(request, runtime);
}

model GetUserOrderConfigRequest {
  operaUid?: string(name='OperaUid'),
}

model GetUserOrderConfigResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model GetUserOrderConfigResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetUserOrderConfigResponseBody(name='body'),
}

async function getUserOrderConfigWithOptions(request: GetUserOrderConfigRequest, runtime: Util.RuntimeOptions): GetUserOrderConfigResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetUserOrderConfig',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getUserOrderConfig(request: GetUserOrderConfigRequest): GetUserOrderConfigResponse {
  var runtime = new Util.RuntimeOptions{};
  return getUserOrderConfigWithOptions(request, runtime);
}

model IgnoreAlarmsRequest {
  alarmId?: string(name='AlarmId'),
}

model IgnoreAlarmsResponseBody = {
  code?: string(name='Code'),
  data?: boolean(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model IgnoreAlarmsResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: IgnoreAlarmsResponseBody(name='body'),
}

async function ignoreAlarmsWithOptions(request: IgnoreAlarmsRequest, runtime: Util.RuntimeOptions): IgnoreAlarmsResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.alarmId)) {
    query['AlarmId'] = request.alarmId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'IgnoreAlarms',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function ignoreAlarms(request: IgnoreAlarmsRequest): IgnoreAlarmsResponse {
  var runtime = new Util.RuntimeOptions{};
  return ignoreAlarmsWithOptions(request, runtime);
}

model ListApplyAuthorizationRequest {
  currentPage?: int32(name='CurrentPage'),
  pageSize?: int32(name='PageSize'),
  permissionType?: int32(name='PermissionType'),
  switchFrontOperaUid?: string(name='SwitchFrontOperaUid'),
  type?: string(name='Type'),
  uid?: long(name='Uid'),
}

model ListApplyAuthorizationResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  pageTotal?: long(name='PageTotal'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model ListApplyAuthorizationResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: ListApplyAuthorizationResponseBody(name='body'),
}

async function listApplyAuthorizationWithOptions(request: ListApplyAuthorizationRequest, runtime: Util.RuntimeOptions): ListApplyAuthorizationResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.currentPage)) {
    query['CurrentPage'] = request.currentPage;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.permissionType)) {
    query['PermissionType'] = request.permissionType;
  }
  if (!Util.isUnset(request.switchFrontOperaUid)) {
    query['SwitchFrontOperaUid'] = request.switchFrontOperaUid;
  }
  if (!Util.isUnset(request.type)) {
    query['Type'] = request.type;
  }
  if (!Util.isUnset(request.uid)) {
    query['Uid'] = request.uid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ListApplyAuthorization',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function listApplyAuthorization(request: ListApplyAuthorizationRequest): ListApplyAuthorizationResponse {
  var runtime = new Util.RuntimeOptions{};
  return listApplyAuthorizationWithOptions(request, runtime);
}

model ListAuthRequest {
  userId?: string(name='UserId'),
}

model ListAuthResponseBody = {
  list?: [ string ](name='List'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
}

model ListAuthResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: ListAuthResponseBody(name='body'),
}

async function listAuthWithOptions(request: ListAuthRequest, runtime: Util.RuntimeOptions): ListAuthResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.userId)) {
    query['UserId'] = request.userId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ListAuth',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function listAuth(request: ListAuthRequest): ListAuthResponse {
  var runtime = new Util.RuntimeOptions{};
  return listAuthWithOptions(request, runtime);
}

model ListAuthorizedUidResponseBody = {
  code?: int32(name='Code'),
  list?: [ long ](name='List'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model ListAuthorizedUidResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: ListAuthorizedUidResponseBody(name='body'),
}

async function listAuthorizedUidWithOptions(runtime: Util.RuntimeOptions): ListAuthorizedUidResponse {
  var req = new OpenApi.OpenApiRequest{};
  var params = new OpenApi.Params{
    action = 'ListAuthorizedUid',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function listAuthorizedUid(): ListAuthorizedUidResponse {
  var runtime = new Util.RuntimeOptions{};
  return listAuthorizedUidWithOptions(runtime);
}

model ListCausePlanRequest {
  eventId?: string(name='EventId'),
  instanceId?: string(name='InstanceId'),
  rootCauseId?: string(name='RootCauseId'),
}

model ListCausePlanResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model ListCausePlanResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: ListCausePlanResponseBody(name='body'),
}

async function listCausePlanWithOptions(request: ListCausePlanRequest, runtime: Util.RuntimeOptions): ListCausePlanResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.eventId)) {
    query['EventId'] = request.eventId;
  }
  if (!Util.isUnset(request.instanceId)) {
    query['InstanceId'] = request.instanceId;
  }
  if (!Util.isUnset(request.rootCauseId)) {
    query['RootCauseId'] = request.rootCauseId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ListCausePlan',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function listCausePlan(request: ListCausePlanRequest): ListCausePlanResponse {
  var runtime = new Util.RuntimeOptions{};
  return listCausePlanWithOptions(request, runtime);
}

model ListConfirmAuthorizationRequest {
  currentPage?: int32(name='CurrentPage'),
  pageSize?: int32(name='PageSize'),
  permissionType?: int32(name='PermissionType'),
  switchFrontOperaUid?: string(name='SwitchFrontOperaUid'),
  type?: string(name='Type'),
  uid?: long(name='Uid'),
}

model ListConfirmAuthorizationResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  pageTotal?: long(name='PageTotal'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model ListConfirmAuthorizationResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: ListConfirmAuthorizationResponseBody(name='body'),
}

async function listConfirmAuthorizationWithOptions(request: ListConfirmAuthorizationRequest, runtime: Util.RuntimeOptions): ListConfirmAuthorizationResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.currentPage)) {
    query['CurrentPage'] = request.currentPage;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.permissionType)) {
    query['PermissionType'] = request.permissionType;
  }
  if (!Util.isUnset(request.switchFrontOperaUid)) {
    query['SwitchFrontOperaUid'] = request.switchFrontOperaUid;
  }
  if (!Util.isUnset(request.type)) {
    query['Type'] = request.type;
  }
  if (!Util.isUnset(request.uid)) {
    query['Uid'] = request.uid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ListConfirmAuthorization',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function listConfirmAuthorization(request: ListConfirmAuthorizationRequest): ListConfirmAuthorizationResponse {
  var runtime = new Util.RuntimeOptions{};
  return listConfirmAuthorizationWithOptions(request, runtime);
}

model ListEventRequest {
  currentPage?: int32(name='CurrentPage'),
  pageSize?: int32(name='PageSize'),
  uid?: long(name='Uid'),
}

model ListEventResponseBody = {
  code?: long(name='Code'),
  list?: [  map[string]any ](name='List'),
  message?: string(name='Message'),
  pageTotal?: long(name='PageTotal'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model ListEventResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: ListEventResponseBody(name='body'),
}

async function listEventWithOptions(request: ListEventRequest, runtime: Util.RuntimeOptions): ListEventResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.currentPage)) {
    query['CurrentPage'] = request.currentPage;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.uid)) {
    query['Uid'] = request.uid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ListEvent',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function listEvent(request: ListEventRequest): ListEventResponse {
  var runtime = new Util.RuntimeOptions{};
  return listEventWithOptions(request, runtime);
}

model ListNotAuthorizedUidResponseBody = {
  code?: int32(name='Code'),
  list?: [ long ](name='List'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model ListNotAuthorizedUidResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: ListNotAuthorizedUidResponseBody(name='body'),
}

async function listNotAuthorizedUidWithOptions(runtime: Util.RuntimeOptions): ListNotAuthorizedUidResponse {
  var req = new OpenApi.OpenApiRequest{};
  var params = new OpenApi.Params{
    action = 'ListNotAuthorizedUid',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function listNotAuthorizedUid(): ListNotAuthorizedUidResponse {
  var runtime = new Util.RuntimeOptions{};
  return listNotAuthorizedUidWithOptions(runtime);
}

model ListReportsRequest {
  currentPage?: int32(name='CurrentPage'),
  pageSize?: int32(name='PageSize'),
  uid?: long(name='Uid'),
}

model ListReportsResponseBody = {
  code?: int32(name='Code'),
  data?: [ 
    {
      bid?: string(name='bid'),
      cid?: long(name='cid'),
      costCount?: long(name='costCount'),
      costCountTrendJson?: string(name='costCountTrendJson'),
      criticalCount?: long(name='criticalCount'),
      criticalCountTrendJson?: string(name='criticalCountTrendJson'),
      customerName?: string(name='customerName'),
      gcLevel?: string(name='gcLevel'),
      gmtCreate?: long(name='gmtCreate'),
      gmtModified?: long(name='gmtModified'),
      id?: long(name='id'),
      normalCount?: long(name='normalCount'),
      normalCountTrendJson?: string(name='normalCountTrendJson'),
      score?: long(name='score'),
      scoreTrendJson?: string(name='scoreTrendJson'),
      trendJson?: string(name='trendJson'),
      uid?: long(name='uid'),
      warningCount?: long(name='warningCount'),
      warningCountTrendJson?: string(name='warningCountTrendJson'),
    }
  ](name='Data'),
  message?: string(name='Message'),
  pageTotal?: long(name='PageTotal'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model ListReportsResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: ListReportsResponseBody(name='body'),
}

async function listReportsWithOptions(request: ListReportsRequest, runtime: Util.RuntimeOptions): ListReportsResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.currentPage)) {
    query['CurrentPage'] = request.currentPage;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.uid)) {
    query['Uid'] = request.uid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ListReports',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function listReports(request: ListReportsRequest): ListReportsResponse {
  var runtime = new Util.RuntimeOptions{};
  return listReportsWithOptions(request, runtime);
}

model ListRootCauseRequest {
  eventId?: string(name='EventId'),
  instanceId?: string(name='InstanceId'),
  rootCauseId?: string(name='RootCauseId'),
}

model ListRootCauseResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model ListRootCauseResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: ListRootCauseResponseBody(name='body'),
}

async function listRootCauseWithOptions(request: ListRootCauseRequest, runtime: Util.RuntimeOptions): ListRootCauseResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.eventId)) {
    query['EventId'] = request.eventId;
  }
  if (!Util.isUnset(request.instanceId)) {
    query['InstanceId'] = request.instanceId;
  }
  if (!Util.isUnset(request.rootCauseId)) {
    query['RootCauseId'] = request.rootCauseId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ListRootCause',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function listRootCause(request: ListRootCauseRequest): ListRootCauseResponse {
  var runtime = new Util.RuntimeOptions{};
  return listRootCauseWithOptions(request, runtime);
}

model ListSlsReportsRequest {
  currentPage?: int32(name='CurrentPage'),
  instanceId?: string(name='InstanceId'),
  logStore?: string(name='LogStore'),
  pageSize?: int32(name='PageSize'),
  productCode?: string(name='ProductCode'),
  severity?: string(name='Severity'),
  uid?: long(name='Uid'),
}

model ListSlsReportsResponseBody = {
  code?: int32(name='Code'),
  data?: [  map[string]any ](name='Data'),
  message?: string(name='Message'),
  pageTotal?: long(name='PageTotal'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model ListSlsReportsResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: ListSlsReportsResponseBody(name='body'),
}

async function listSlsReportsWithOptions(request: ListSlsReportsRequest, runtime: Util.RuntimeOptions): ListSlsReportsResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.currentPage)) {
    query['CurrentPage'] = request.currentPage;
  }
  if (!Util.isUnset(request.instanceId)) {
    query['InstanceId'] = request.instanceId;
  }
  if (!Util.isUnset(request.logStore)) {
    query['LogStore'] = request.logStore;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.productCode)) {
    query['ProductCode'] = request.productCode;
  }
  if (!Util.isUnset(request.severity)) {
    query['Severity'] = request.severity;
  }
  if (!Util.isUnset(request.uid)) {
    query['Uid'] = request.uid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ListSlsReports',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function listSlsReports(request: ListSlsReportsRequest): ListSlsReportsResponse {
  var runtime = new Util.RuntimeOptions{};
  return listSlsReportsWithOptions(request, runtime);
}

model PutAlertContactRequest {
  email?: string(name='Email'),
  id?: long(name='Id'),
  name?: string(name='Name'),
  operaUid?: string(name='OperaUid'),
  phone?: string(name='Phone'),
  webhook?: string(name='Webhook'),
}

model PutAlertContactResponseBody = {
  code?: int32(name='Code'),
  data?: boolean(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model PutAlertContactResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: PutAlertContactResponseBody(name='body'),
}

async function putAlertContactWithOptions(request: PutAlertContactRequest, runtime: Util.RuntimeOptions): PutAlertContactResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  var body : map[string]any = {};
  if (!Util.isUnset(request.email)) {
    body['Email'] = request.email;
  }
  if (!Util.isUnset(request.id)) {
    body['Id'] = request.id;
  }
  if (!Util.isUnset(request.name)) {
    body['Name'] = request.name;
  }
  if (!Util.isUnset(request.phone)) {
    body['Phone'] = request.phone;
  }
  if (!Util.isUnset(request.webhook)) {
    body['Webhook'] = request.webhook;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'PutAlertContact',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function putAlertContact(request: PutAlertContactRequest): PutAlertContactResponse {
  var runtime = new Util.RuntimeOptions{};
  return putAlertContactWithOptions(request, runtime);
}

model PutAlertContactGroupRequest {
  alertContactGroupJson?: string(name='AlertContactGroupJson'),
  contactIdsJson?: string(name='ContactIdsJson'),
  operaUid?: string(name='OperaUid'),
}

model PutAlertContactGroupResponseBody = {
  code?: int32(name='Code'),
  data?: boolean(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model PutAlertContactGroupResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: PutAlertContactGroupResponseBody(name='body'),
}

async function putAlertContactGroupWithOptions(request: PutAlertContactGroupRequest, runtime: Util.RuntimeOptions): PutAlertContactGroupResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  var body : map[string]any = {};
  if (!Util.isUnset(request.alertContactGroupJson)) {
    body['AlertContactGroupJson'] = request.alertContactGroupJson;
  }
  if (!Util.isUnset(request.contactIdsJson)) {
    body['ContactIdsJson'] = request.contactIdsJson;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'PutAlertContactGroup',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function putAlertContactGroup(request: PutAlertContactGroupRequest): PutAlertContactGroupResponse {
  var runtime = new Util.RuntimeOptions{};
  return putAlertContactGroupWithOptions(request, runtime);
}

model PutAlertContactToGroupRequest {
  contactIdListJson?: string(name='ContactIdListJson'),
  groupId?: long(name='GroupId'),
  groupIdListJson?: string(name='GroupIdListJson'),
  operaUid?: string(name='OperaUid'),
}

model PutAlertContactToGroupResponseBody = {
  code?: int32(name='Code'),
  data?: boolean(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model PutAlertContactToGroupResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: PutAlertContactToGroupResponseBody(name='body'),
}

async function putAlertContactToGroupWithOptions(request: PutAlertContactToGroupRequest, runtime: Util.RuntimeOptions): PutAlertContactToGroupResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  var body : map[string]any = {};
  if (!Util.isUnset(request.contactIdListJson)) {
    body['ContactIdListJson'] = request.contactIdListJson;
  }
  if (!Util.isUnset(request.groupId)) {
    body['GroupId'] = request.groupId;
  }
  if (!Util.isUnset(request.groupIdListJson)) {
    body['GroupIdListJson'] = request.groupIdListJson;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'PutAlertContactToGroup',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function putAlertContactToGroup(request: PutAlertContactToGroupRequest): PutAlertContactToGroupResponse {
  var runtime = new Util.RuntimeOptions{};
  return putAlertContactToGroupWithOptions(request, runtime);
}

model PutAlertIgnoreRequest {
  alertId?: long(name='AlertId'),
  operaUid?: string(name='OperaUid'),
}

model PutAlertIgnoreResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model PutAlertIgnoreResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: PutAlertIgnoreResponseBody(name='body'),
}

async function putAlertIgnoreWithOptions(request: PutAlertIgnoreRequest, runtime: Util.RuntimeOptions): PutAlertIgnoreResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.alertId)) {
    query['AlertId'] = request.alertId;
  }
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'PutAlertIgnore',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function putAlertIgnore(request: PutAlertIgnoreRequest): PutAlertIgnoreResponse {
  var runtime = new Util.RuntimeOptions{};
  return putAlertIgnoreWithOptions(request, runtime);
}

model PutAlertSettingRequest {
  alarmLevel?: string(name='AlarmLevel'),
  alertName?: string(name='AlertName'),
  alertSettingId?: long(name='AlertSettingId'),
  alertSilenceConfig?: string(name='AlertSilenceConfig'),
  businessGroupIdsJson?: string(name='BusinessGroupIdsJson'),
  contactGroupIdsJson?: string(name='ContactGroupIdsJson'),
  contactIdsJson?: string(name='ContactIdsJson'),
  customerUid?: long(name='CustomerUid'),
  operaUid?: string(name='OperaUid'),
  sendDingtalkNotice?: boolean(name='SendDingtalkNotice'),
  sendEmailNotice?: boolean(name='SendEmailNotice'),
  sendSmsNotice?: boolean(name='SendSmsNotice'),
  stopDuration?: long(name='StopDuration'),
}

model PutAlertSettingResponseBody = {
  code?: int32(name='Code'),
  data?: boolean(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model PutAlertSettingResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: PutAlertSettingResponseBody(name='body'),
}

async function putAlertSettingWithOptions(request: PutAlertSettingRequest, runtime: Util.RuntimeOptions): PutAlertSettingResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.alertSilenceConfig)) {
    query['AlertSilenceConfig'] = request.alertSilenceConfig;
  }
  var body : map[string]any = {};
  if (!Util.isUnset(request.alarmLevel)) {
    body['AlarmLevel'] = request.alarmLevel;
  }
  if (!Util.isUnset(request.alertName)) {
    body['AlertName'] = request.alertName;
  }
  if (!Util.isUnset(request.alertSettingId)) {
    body['AlertSettingId'] = request.alertSettingId;
  }
  if (!Util.isUnset(request.businessGroupIdsJson)) {
    body['BusinessGroupIdsJson'] = request.businessGroupIdsJson;
  }
  if (!Util.isUnset(request.contactGroupIdsJson)) {
    body['ContactGroupIdsJson'] = request.contactGroupIdsJson;
  }
  if (!Util.isUnset(request.contactIdsJson)) {
    body['ContactIdsJson'] = request.contactIdsJson;
  }
  if (!Util.isUnset(request.customerUid)) {
    body['CustomerUid'] = request.customerUid;
  }
  if (!Util.isUnset(request.operaUid)) {
    body['OperaUid'] = request.operaUid;
  }
  if (!Util.isUnset(request.sendDingtalkNotice)) {
    body['SendDingtalkNotice'] = request.sendDingtalkNotice;
  }
  if (!Util.isUnset(request.sendEmailNotice)) {
    body['SendEmailNotice'] = request.sendEmailNotice;
  }
  if (!Util.isUnset(request.sendSmsNotice)) {
    body['SendSmsNotice'] = request.sendSmsNotice;
  }
  if (!Util.isUnset(request.stopDuration)) {
    body['StopDuration'] = request.stopDuration;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'PutAlertSetting',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function putAlertSetting(request: PutAlertSettingRequest): PutAlertSettingResponse {
  var runtime = new Util.RuntimeOptions{};
  return putAlertSettingWithOptions(request, runtime);
}

model PutAlertSettingListRequest {
  alertSettingEditRequestListJson?: string(name='AlertSettingEditRequestListJson'),
  contactGroupIdsJson?: string(name='ContactGroupIdsJson'),
  contactIdsJson?: string(name='ContactIdsJson'),
}

model PutAlertSettingListResponseBody = {
  code?: int32(name='Code'),
  data?: boolean(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model PutAlertSettingListResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: PutAlertSettingListResponseBody(name='body'),
}

async function putAlertSettingListWithOptions(request: PutAlertSettingListRequest, runtime: Util.RuntimeOptions): PutAlertSettingListResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.alertSettingEditRequestListJson)) {
    body['AlertSettingEditRequestListJson'] = request.alertSettingEditRequestListJson;
  }
  if (!Util.isUnset(request.contactGroupIdsJson)) {
    body['ContactGroupIdsJson'] = request.contactGroupIdsJson;
  }
  if (!Util.isUnset(request.contactIdsJson)) {
    body['ContactIdsJson'] = request.contactIdsJson;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'PutAlertSettingList',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function putAlertSettingList(request: PutAlertSettingListRequest): PutAlertSettingListResponse {
  var runtime = new Util.RuntimeOptions{};
  return putAlertSettingListWithOptions(request, runtime);
}

model PutAlertSettingStatusRequest {
  alertSettingId?: long(name='AlertSettingId'),
  operaUid?: string(name='OperaUid'),
  settingStatus?: long(name='SettingStatus'),
}

model PutAlertSettingStatusResponseBody = {
  code?: int32(name='Code'),
  data?: boolean(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model PutAlertSettingStatusResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: PutAlertSettingStatusResponseBody(name='body'),
}

async function putAlertSettingStatusWithOptions(request: PutAlertSettingStatusRequest, runtime: Util.RuntimeOptions): PutAlertSettingStatusResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.alertSettingId)) {
    body['AlertSettingId'] = request.alertSettingId;
  }
  if (!Util.isUnset(request.operaUid)) {
    body['OperaUid'] = request.operaUid;
  }
  if (!Util.isUnset(request.settingStatus)) {
    body['SettingStatus'] = request.settingStatus;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'PutAlertSettingStatus',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function putAlertSettingStatus(request: PutAlertSettingStatusRequest): PutAlertSettingStatusResponse {
  var runtime = new Util.RuntimeOptions{};
  return putAlertSettingStatusWithOptions(request, runtime);
}

model PutDataSourceConfigRequest {
  dataSourceDescribe?: string(name='DataSourceDescribe'),
  dataSourceName?: string(name='DataSourceName'),
  dataSourceParams?: string(name='DataSourceParams'),
  dataSourceParamsMapping?: string(name='DataSourceParamsMapping'),
  dataSourceType?: int32(name='DataSourceType'),
  operaUid?: string(name='OperaUid'),
}

model PutDataSourceConfigResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model PutDataSourceConfigResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: PutDataSourceConfigResponseBody(name='body'),
}

async function putDataSourceConfigWithOptions(request: PutDataSourceConfigRequest, runtime: Util.RuntimeOptions): PutDataSourceConfigResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.dataSourceDescribe)) {
    query['DataSourceDescribe'] = request.dataSourceDescribe;
  }
  if (!Util.isUnset(request.dataSourceName)) {
    query['DataSourceName'] = request.dataSourceName;
  }
  if (!Util.isUnset(request.dataSourceParams)) {
    query['DataSourceParams'] = request.dataSourceParams;
  }
  if (!Util.isUnset(request.dataSourceParamsMapping)) {
    query['DataSourceParamsMapping'] = request.dataSourceParamsMapping;
  }
  if (!Util.isUnset(request.dataSourceType)) {
    query['DataSourceType'] = request.dataSourceType;
  }
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'PutDataSourceConfig',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function putDataSourceConfig(request: PutDataSourceConfigRequest): PutDataSourceConfigResponse {
  var runtime = new Util.RuntimeOptions{};
  return putDataSourceConfigWithOptions(request, runtime);
}

model PutGroupResourceTagRequest {
  businessGroupId?: string(name='BusinessGroupId'),
  operaUid?: string(name='OperaUid'),
  productId?: string(name='ProductId'),
  resources?: string(name='Resources'),
  tagId?: string(name='TagId'),
}

model PutGroupResourceTagResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model PutGroupResourceTagResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: PutGroupResourceTagResponseBody(name='body'),
}

async function putGroupResourceTagWithOptions(request: PutGroupResourceTagRequest, runtime: Util.RuntimeOptions): PutGroupResourceTagResponse {
  Util.validateModel(request);
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'PutGroupResourceTag',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function putGroupResourceTag(request: PutGroupResourceTagRequest): PutGroupResourceTagResponse {
  var runtime = new Util.RuntimeOptions{};
  return putGroupResourceTagWithOptions(request, runtime);
}

model PutGroupTopologyTagLogRequest {
  businessGroupId?: string(name='BusinessGroupId'),
  operaUid?: string(name='OperaUid'),
  topologyTag?: string(name='TopologyTag'),
  topologyTagShow?: string(name='TopologyTagShow'),
}

model PutGroupTopologyTagLogResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model PutGroupTopologyTagLogResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: PutGroupTopologyTagLogResponseBody(name='body'),
}

async function putGroupTopologyTagLogWithOptions(request: PutGroupTopologyTagLogRequest, runtime: Util.RuntimeOptions): PutGroupTopologyTagLogResponse {
  Util.validateModel(request);
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'PutGroupTopologyTagLog',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function putGroupTopologyTagLog(request: PutGroupTopologyTagLogRequest): PutGroupTopologyTagLogResponse {
  var runtime = new Util.RuntimeOptions{};
  return putGroupTopologyTagLogWithOptions(request, runtime);
}

model PutReportEmailConfigRequest {
  email?: string(name='Email'),
  operaUid?: string(name='OperaUid'),
}

model PutReportEmailConfigResponseBody = {
  code?: int32(name='Code'),
  data?: boolean(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model PutReportEmailConfigResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: PutReportEmailConfigResponseBody(name='body'),
}

async function putReportEmailConfigWithOptions(request: PutReportEmailConfigRequest, runtime: Util.RuntimeOptions): PutReportEmailConfigResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.email)) {
    body['Email'] = request.email;
  }
  if (!Util.isUnset(request.operaUid)) {
    body['OperaUid'] = request.operaUid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'PutReportEmailConfig',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function putReportEmailConfig(request: PutReportEmailConfigRequest): PutReportEmailConfigResponse {
  var runtime = new Util.RuntimeOptions{};
  return putReportEmailConfigWithOptions(request, runtime);
}

model PutResourceWhitelistRequest {
  operaUid?: string(name='OperaUid'),
  productCode?: string(name='ProductCode'),
  resourceId?: string(name='ResourceId'),
}

model PutResourceWhitelistResponseBody = {
  code?: int32(name='Code'),
  data?: boolean(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model PutResourceWhitelistResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: PutResourceWhitelistResponseBody(name='body'),
}

async function putResourceWhitelistWithOptions(request: PutResourceWhitelistRequest, runtime: Util.RuntimeOptions): PutResourceWhitelistResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.operaUid)) {
    body['OperaUid'] = request.operaUid;
  }
  if (!Util.isUnset(request.productCode)) {
    body['ProductCode'] = request.productCode;
  }
  if (!Util.isUnset(request.resourceId)) {
    body['ResourceId'] = request.resourceId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'PutResourceWhitelist',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function putResourceWhitelist(request: PutResourceWhitelistRequest): PutResourceWhitelistResponse {
  var runtime = new Util.RuntimeOptions{};
  return putResourceWhitelistWithOptions(request, runtime);
}

model ReplaceScriptListRequest {
  id?: int32(name='Id'),
  operaUid?: string(name='OperaUid'),
  sceneId?: string(name='SceneId'),
  type?: int32(name='Type'),
}

model ReplaceScriptListResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model ReplaceScriptListResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: ReplaceScriptListResponseBody(name='body'),
}

async function replaceScriptListWithOptions(request: ReplaceScriptListRequest, runtime: Util.RuntimeOptions): ReplaceScriptListResponse {
  Util.validateModel(request);
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ReplaceScriptList',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function replaceScriptList(request: ReplaceScriptListRequest): ReplaceScriptListResponse {
  var runtime = new Util.RuntimeOptions{};
  return replaceScriptListWithOptions(request, runtime);
}

model RevokeSubmitApplyPermissionRequest {
  switchFrontOperaUid?: string(name='SwitchFrontOperaUid'),
  type?: string(name='Type'),
  uid?: long(name='Uid'),
}

model RevokeSubmitApplyPermissionResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model RevokeSubmitApplyPermissionResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: RevokeSubmitApplyPermissionResponseBody(name='body'),
}

async function revokeSubmitApplyPermissionWithOptions(request: RevokeSubmitApplyPermissionRequest, runtime: Util.RuntimeOptions): RevokeSubmitApplyPermissionResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.switchFrontOperaUid)) {
    query['SwitchFrontOperaUid'] = request.switchFrontOperaUid;
  }
  if (!Util.isUnset(request.type)) {
    query['Type'] = request.type;
  }
  if (!Util.isUnset(request.uid)) {
    query['Uid'] = request.uid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'RevokeSubmitApplyPermission',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function revokeSubmitApplyPermission(request: RevokeSubmitApplyPermissionRequest): RevokeSubmitApplyPermissionResponse {
  var runtime = new Util.RuntimeOptions{};
  return revokeSubmitApplyPermissionWithOptions(request, runtime);
}

model RunAnalysisProcessRequest {
  eventId?: string(name='EventId'),
  operaUid?: string(name='OperaUid'),
}

model RunAnalysisProcessResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model RunAnalysisProcessResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: RunAnalysisProcessResponseBody(name='body'),
}

async function runAnalysisProcessWithOptions(request: RunAnalysisProcessRequest, runtime: Util.RuntimeOptions): RunAnalysisProcessResponse {
  Util.validateModel(request);
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'RunAnalysisProcess',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function runAnalysisProcess(request: RunAnalysisProcessRequest): RunAnalysisProcessResponse {
  var runtime = new Util.RuntimeOptions{};
  return runAnalysisProcessWithOptions(request, runtime);
}

model RunCommandRequest {
  commandContent?: string(name='CommandContent'),
  instanceIds?: string(name='InstanceIds'),
  name?: string(name='Name'),
  regionId?: string(name='RegionId'),
  type?: string(name='Type'),
}

model RunCommandResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: boolean(name='Status'),
}

model RunCommandResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: RunCommandResponseBody(name='body'),
}

async function runCommandWithOptions(request: RunCommandRequest, runtime: Util.RuntimeOptions): RunCommandResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.commandContent)) {
    query['CommandContent'] = request.commandContent;
  }
  if (!Util.isUnset(request.instanceIds)) {
    query['InstanceIds'] = request.instanceIds;
  }
  if (!Util.isUnset(request.name)) {
    query['Name'] = request.name;
  }
  if (!Util.isUnset(request.regionId)) {
    query['RegionId'] = request.regionId;
  }
  if (!Util.isUnset(request.type)) {
    query['Type'] = request.type;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'RunCommand',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function runCommand(request: RunCommandRequest): RunCommandResponse {
  var runtime = new Util.RuntimeOptions{};
  return runCommandWithOptions(request, runtime);
}

model RunForecastAnalyzeRequest {
  eventId?: string(name='EventId'),
  operaUid?: string(name='OperaUid'),
}

model RunForecastAnalyzeResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model RunForecastAnalyzeResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: RunForecastAnalyzeResponseBody(name='body'),
}

async function runForecastAnalyzeWithOptions(request: RunForecastAnalyzeRequest, runtime: Util.RuntimeOptions): RunForecastAnalyzeResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.eventId)) {
    query['EventId'] = request.eventId;
  }
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'RunForecastAnalyze',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function runForecastAnalyze(request: RunForecastAnalyzeRequest): RunForecastAnalyzeResponse {
  var runtime = new Util.RuntimeOptions{};
  return runForecastAnalyzeWithOptions(request, runtime);
}

model RunPatrolInspectionRequest {
  operaUid?: string(name='OperaUid'),
  productCodes?: string(name='ProductCodes'),
  riskCodeList?: string(name='RiskCodeList'),
}

model RunPatrolInspectionResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model RunPatrolInspectionResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: RunPatrolInspectionResponseBody(name='body'),
}

async function runPatrolInspectionWithOptions(request: RunPatrolInspectionRequest, runtime: Util.RuntimeOptions): RunPatrolInspectionResponse {
  Util.validateModel(request);
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'RunPatrolInspection',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function runPatrolInspection(request: RunPatrolInspectionRequest): RunPatrolInspectionResponse {
  var runtime = new Util.RuntimeOptions{};
  return runPatrolInspectionWithOptions(request, runtime);
}

model RunRepairScriptRequest {
  eventId?: string(name='EventId'),
  operaUid?: string(name='OperaUid'),
}

model RunRepairScriptResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model RunRepairScriptResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: RunRepairScriptResponseBody(name='body'),
}

async function runRepairScriptWithOptions(request: RunRepairScriptRequest, runtime: Util.RuntimeOptions): RunRepairScriptResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.eventId)) {
    query['EventId'] = request.eventId;
  }
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'RunRepairScript',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function runRepairScript(request: RunRepairScriptRequest): RunRepairScriptResponse {
  var runtime = new Util.RuntimeOptions{};
  return runRepairScriptWithOptions(request, runtime);
}

model RunRiskPatrolRequest {
  operaUid?: string(name='OperaUid'),
  riskPatrolTypes?: string(name='RiskPatrolTypes'),
}

model RunRiskPatrolResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model RunRiskPatrolResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: RunRiskPatrolResponseBody(name='body'),
}

async function runRiskPatrolWithOptions(request: RunRiskPatrolRequest, runtime: Util.RuntimeOptions): RunRiskPatrolResponse {
  Util.validateModel(request);
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'RunRiskPatrol',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function runRiskPatrol(request: RunRiskPatrolRequest): RunRiskPatrolResponse {
  var runtime = new Util.RuntimeOptions{};
  return runRiskPatrolWithOptions(request, runtime);
}

model SwitchUserTopRequest {
  switchFrontOperaUid?: string(name='SwitchFrontOperaUid'),
  type?: string(name='Type'),
  uid?: long(name='Uid'),
}

model SwitchUserTopResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model SwitchUserTopResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: SwitchUserTopResponseBody(name='body'),
}

async function switchUserTopWithOptions(request: SwitchUserTopRequest, runtime: Util.RuntimeOptions): SwitchUserTopResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.switchFrontOperaUid)) {
    query['SwitchFrontOperaUid'] = request.switchFrontOperaUid;
  }
  if (!Util.isUnset(request.type)) {
    query['Type'] = request.type;
  }
  if (!Util.isUnset(request.uid)) {
    query['Uid'] = request.uid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'SwitchUserTop',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function switchUserTop(request: SwitchUserTopRequest): SwitchUserTopResponse {
  var runtime = new Util.RuntimeOptions{};
  return switchUserTopWithOptions(request, runtime);
}

model UpdBusinessGroupRequest {
  aliUid?: string(name='AliUid'),
  businessGroupDesc?: string(name='BusinessGroupDesc'),
  businessGroupId?: string(name='BusinessGroupId'),
  businessGroupName?: string(name='BusinessGroupName'),
  instanceList?: [ string ](name='InstanceList'),
  resourceType?: int32(name='ResourceType'),
  updateUser?: string(name='UpdateUser'),
}

model UpdBusinessGroupShrinkRequest {
  aliUid?: string(name='AliUid'),
  businessGroupDesc?: string(name='BusinessGroupDesc'),
  businessGroupId?: string(name='BusinessGroupId'),
  businessGroupName?: string(name='BusinessGroupName'),
  instanceListShrink?: string(name='InstanceList'),
  resourceType?: int32(name='ResourceType'),
  updateUser?: string(name='UpdateUser'),
}

model UpdBusinessGroupResponseBody = {
  code?: int32(name='Code'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model UpdBusinessGroupResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: UpdBusinessGroupResponseBody(name='body'),
}

async function updBusinessGroupWithOptions(tmpReq: UpdBusinessGroupRequest, runtime: Util.RuntimeOptions): UpdBusinessGroupResponse {
  Util.validateModel(tmpReq);
  var request = new UpdBusinessGroupShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.instanceList)) {
    request.instanceListShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.instanceList, 'InstanceList', 'json');
  }
  var query = {};
  if (!Util.isUnset(request.aliUid)) {
    query['AliUid'] = request.aliUid;
  }
  if (!Util.isUnset(request.businessGroupDesc)) {
    query['BusinessGroupDesc'] = request.businessGroupDesc;
  }
  if (!Util.isUnset(request.businessGroupId)) {
    query['BusinessGroupId'] = request.businessGroupId;
  }
  if (!Util.isUnset(request.businessGroupName)) {
    query['BusinessGroupName'] = request.businessGroupName;
  }
  if (!Util.isUnset(request.instanceListShrink)) {
    query['InstanceList'] = request.instanceListShrink;
  }
  if (!Util.isUnset(request.resourceType)) {
    query['ResourceType'] = request.resourceType;
  }
  if (!Util.isUnset(request.updateUser)) {
    query['UpdateUser'] = request.updateUser;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'UpdBusinessGroup',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function updBusinessGroup(request: UpdBusinessGroupRequest): UpdBusinessGroupResponse {
  var runtime = new Util.RuntimeOptions{};
  return updBusinessGroupWithOptions(request, runtime);
}

model UpdateAuthorizationRequest {
  type?: string(name='Type'),
  userId?: string(name='UserId'),
}

model UpdateAuthorizationResponseBody = {
  code?: string(name='Code'),
  data?: string(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model UpdateAuthorizationResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: UpdateAuthorizationResponseBody(name='body'),
}

async function updateAuthorizationWithOptions(request: UpdateAuthorizationRequest, runtime: Util.RuntimeOptions): UpdateAuthorizationResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.type)) {
    query['Type'] = request.type;
  }
  if (!Util.isUnset(request.userId)) {
    query['UserId'] = request.userId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'UpdateAuthorization',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function updateAuthorization(request: UpdateAuthorizationRequest): UpdateAuthorizationResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateAuthorizationWithOptions(request, runtime);
}

model UpdateBindMetricRequest {
  id?: string(name='Id'),
  metricId?: long(name='MetricId'),
  operaUid?: string(name='OperaUid'),
}

model UpdateBindMetricResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  pageTotal?: long(name='PageTotal'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model UpdateBindMetricResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: UpdateBindMetricResponseBody(name='body'),
}

async function updateBindMetricWithOptions(request: UpdateBindMetricRequest, runtime: Util.RuntimeOptions): UpdateBindMetricResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.id)) {
    query['Id'] = request.id;
  }
  if (!Util.isUnset(request.metricId)) {
    query['MetricId'] = request.metricId;
  }
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'UpdateBindMetric',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function updateBindMetric(request: UpdateBindMetricRequest): UpdateBindMetricResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateBindMetricWithOptions(request, runtime);
}

model UpdateBusinessGroupRequest {
  aliUid?: string(name='AliUid'),
  businessGroupDesc?: string(name='BusinessGroupDesc'),
  businessGroupId?: string(name='BusinessGroupId'),
  businessGroupName?: string(name='BusinessGroupName'),
  cloudResourceTypeId?: string(name='CloudResourceTypeId'),
  dealType?: int32(name='DealType'),
  instanceList?: [ string ](name='InstanceList'),
  operaUid?: string(name='OperaUid'),
  resourceType?: int32(name='ResourceType'),
  updateUser?: string(name='UpdateUser'),
}

model UpdateBusinessGroupShrinkRequest {
  aliUid?: string(name='AliUid'),
  businessGroupDesc?: string(name='BusinessGroupDesc'),
  businessGroupId?: string(name='BusinessGroupId'),
  businessGroupName?: string(name='BusinessGroupName'),
  cloudResourceTypeId?: string(name='CloudResourceTypeId'),
  dealType?: int32(name='DealType'),
  instanceListShrink?: string(name='InstanceList'),
  operaUid?: string(name='OperaUid'),
  resourceType?: int32(name='ResourceType'),
  updateUser?: string(name='UpdateUser'),
}

model UpdateBusinessGroupResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model UpdateBusinessGroupResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: UpdateBusinessGroupResponseBody(name='body'),
}

async function updateBusinessGroupWithOptions(tmpReq: UpdateBusinessGroupRequest, runtime: Util.RuntimeOptions): UpdateBusinessGroupResponse {
  Util.validateModel(tmpReq);
  var request = new UpdateBusinessGroupShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.instanceList)) {
    request.instanceListShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.instanceList, 'InstanceList', 'json');
  }
  var query = {};
  if (!Util.isUnset(request.aliUid)) {
    query['AliUid'] = request.aliUid;
  }
  if (!Util.isUnset(request.businessGroupDesc)) {
    query['BusinessGroupDesc'] = request.businessGroupDesc;
  }
  if (!Util.isUnset(request.businessGroupId)) {
    query['BusinessGroupId'] = request.businessGroupId;
  }
  if (!Util.isUnset(request.businessGroupName)) {
    query['BusinessGroupName'] = request.businessGroupName;
  }
  if (!Util.isUnset(request.cloudResourceTypeId)) {
    query['CloudResourceTypeId'] = request.cloudResourceTypeId;
  }
  if (!Util.isUnset(request.dealType)) {
    query['DealType'] = request.dealType;
  }
  if (!Util.isUnset(request.instanceListShrink)) {
    query['InstanceList'] = request.instanceListShrink;
  }
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  if (!Util.isUnset(request.resourceType)) {
    query['ResourceType'] = request.resourceType;
  }
  if (!Util.isUnset(request.updateUser)) {
    query['UpdateUser'] = request.updateUser;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'UpdateBusinessGroup',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function updateBusinessGroup(request: UpdateBusinessGroupRequest): UpdateBusinessGroupResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateBusinessGroupWithOptions(request, runtime);
}

model UpdateBusinessMetricAlertConfigRequest {
  alertConfigId?: long(name='AlertConfigId'),
  configs?: string(name='Configs'),
  metricId?: long(name='MetricId'),
  operaUid?: string(name='OperaUid'),
}

model UpdateBusinessMetricAlertConfigResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model UpdateBusinessMetricAlertConfigResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: UpdateBusinessMetricAlertConfigResponseBody(name='body'),
}

async function updateBusinessMetricAlertConfigWithOptions(request: UpdateBusinessMetricAlertConfigRequest, runtime: Util.RuntimeOptions): UpdateBusinessMetricAlertConfigResponse {
  Util.validateModel(request);
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'UpdateBusinessMetricAlertConfig',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function updateBusinessMetricAlertConfig(request: UpdateBusinessMetricAlertConfigRequest): UpdateBusinessMetricAlertConfigResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateBusinessMetricAlertConfigWithOptions(request, runtime);
}

model UpdateBusinessMetricResourceRequest {
  businessMetricId?: long(name='BusinessMetricId'),
  operaUid?: string(name='OperaUid'),
  resourceList?: string(name='ResourceList'),
}

model UpdateBusinessMetricResourceResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  pageTotal?: long(name='PageTotal'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model UpdateBusinessMetricResourceResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: UpdateBusinessMetricResourceResponseBody(name='body'),
}

async function updateBusinessMetricResourceWithOptions(request: UpdateBusinessMetricResourceRequest, runtime: Util.RuntimeOptions): UpdateBusinessMetricResourceResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.businessMetricId)) {
    query['BusinessMetricId'] = request.businessMetricId;
  }
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  if (!Util.isUnset(request.resourceList)) {
    query['ResourceList'] = request.resourceList;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'UpdateBusinessMetricResource',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function updateBusinessMetricResource(request: UpdateBusinessMetricResourceRequest): UpdateBusinessMetricResourceResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateBusinessMetricResourceWithOptions(request, runtime);
}

model UpdateDataSourceConfigRequest {
  dataSourceDescribe?: string(name='DataSourceDescribe'),
  dataSourceName?: string(name='DataSourceName'),
  dataSourceParams?: string(name='DataSourceParams'),
  dataSourceParamsMapping?: string(name='DataSourceParamsMapping'),
  dataSourceType?: int32(name='DataSourceType'),
  id?: long(name='Id'),
  operaUid?: string(name='OperaUid'),
}

model UpdateDataSourceConfigResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model UpdateDataSourceConfigResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: UpdateDataSourceConfigResponseBody(name='body'),
}

async function updateDataSourceConfigWithOptions(request: UpdateDataSourceConfigRequest, runtime: Util.RuntimeOptions): UpdateDataSourceConfigResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.dataSourceDescribe)) {
    query['DataSourceDescribe'] = request.dataSourceDescribe;
  }
  if (!Util.isUnset(request.dataSourceName)) {
    query['DataSourceName'] = request.dataSourceName;
  }
  if (!Util.isUnset(request.dataSourceParams)) {
    query['DataSourceParams'] = request.dataSourceParams;
  }
  if (!Util.isUnset(request.dataSourceParamsMapping)) {
    query['DataSourceParamsMapping'] = request.dataSourceParamsMapping;
  }
  if (!Util.isUnset(request.dataSourceType)) {
    query['DataSourceType'] = request.dataSourceType;
  }
  if (!Util.isUnset(request.id)) {
    query['Id'] = request.id;
  }
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'UpdateDataSourceConfig',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function updateDataSourceConfig(request: UpdateDataSourceConfigRequest): UpdateDataSourceConfigResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateDataSourceConfigWithOptions(request, runtime);
}

model UpdateHandleRiskRequest {
  patrolDetailIds?: string(name='PatrolDetailIds'),
  patrolId?: long(name='PatrolId'),
  switchFrontOperaUid?: string(name='SwitchFrontOperaUid'),
}

model UpdateHandleRiskResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model UpdateHandleRiskResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: UpdateHandleRiskResponseBody(name='body'),
}

async function updateHandleRiskWithOptions(request: UpdateHandleRiskRequest, runtime: Util.RuntimeOptions): UpdateHandleRiskResponse {
  Util.validateModel(request);
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'UpdateHandleRisk',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function updateHandleRisk(request: UpdateHandleRiskRequest): UpdateHandleRiskResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateHandleRiskWithOptions(request, runtime);
}

model UpdateHandleRiskBaseRequest {
  handleDescribe?: string(name='HandleDescribe'),
  operaUid?: string(name='OperaUid'),
  patrolDetailIds?: string(name='PatrolDetailIds'),
  patrolId?: long(name='PatrolId'),
}

model UpdateHandleRiskBaseResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  pageTotal?: long(name='PageTotal'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model UpdateHandleRiskBaseResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: UpdateHandleRiskBaseResponseBody(name='body'),
}

async function updateHandleRiskBaseWithOptions(request: UpdateHandleRiskBaseRequest, runtime: Util.RuntimeOptions): UpdateHandleRiskBaseResponse {
  Util.validateModel(request);
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'UpdateHandleRiskBase',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function updateHandleRiskBase(request: UpdateHandleRiskBaseRequest): UpdateHandleRiskBaseResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateHandleRiskBaseWithOptions(request, runtime);
}

model UpdateIgnoreRiskRequest {
  patrolDetailIds?: string(name='PatrolDetailIds'),
  patrolId?: long(name='PatrolId'),
  switchFrontOperaUid?: string(name='SwitchFrontOperaUid'),
}

model UpdateIgnoreRiskResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model UpdateIgnoreRiskResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: UpdateIgnoreRiskResponseBody(name='body'),
}

async function updateIgnoreRiskWithOptions(request: UpdateIgnoreRiskRequest, runtime: Util.RuntimeOptions): UpdateIgnoreRiskResponse {
  Util.validateModel(request);
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'UpdateIgnoreRisk',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function updateIgnoreRisk(request: UpdateIgnoreRiskRequest): UpdateIgnoreRiskResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateIgnoreRiskWithOptions(request, runtime);
}

model UpdateIgnoreRiskBaseRequest {
  handleDescribe?: string(name='HandleDescribe'),
  operaUid?: string(name='OperaUid'),
  patrolDetailIds?: string(name='PatrolDetailIds'),
  patrolId?: long(name='PatrolId'),
}

model UpdateIgnoreRiskBaseResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  pageTotal?: long(name='PageTotal'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model UpdateIgnoreRiskBaseResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: UpdateIgnoreRiskBaseResponseBody(name='body'),
}

async function updateIgnoreRiskBaseWithOptions(request: UpdateIgnoreRiskBaseRequest, runtime: Util.RuntimeOptions): UpdateIgnoreRiskBaseResponse {
  Util.validateModel(request);
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'UpdateIgnoreRiskBase',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function updateIgnoreRiskBase(request: UpdateIgnoreRiskBaseRequest): UpdateIgnoreRiskBaseResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateIgnoreRiskBaseWithOptions(request, runtime);
}

model UpdateInspectionSettingStatusRequest {
  operaUid?: string(name='OperaUid'),
  riskCode?: string(name='RiskCode'),
  riskEnableStatus?: int32(name='RiskEnableStatus'),
}

model UpdateInspectionSettingStatusResponseBody = {
  code?: int32(name='Code'),
  data?: boolean(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model UpdateInspectionSettingStatusResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: UpdateInspectionSettingStatusResponseBody(name='body'),
}

async function updateInspectionSettingStatusWithOptions(request: UpdateInspectionSettingStatusRequest, runtime: Util.RuntimeOptions): UpdateInspectionSettingStatusResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.operaUid)) {
    body['OperaUid'] = request.operaUid;
  }
  if (!Util.isUnset(request.riskCode)) {
    body['RiskCode'] = request.riskCode;
  }
  if (!Util.isUnset(request.riskEnableStatus)) {
    body['RiskEnableStatus'] = request.riskEnableStatus;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'UpdateInspectionSettingStatus',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function updateInspectionSettingStatus(request: UpdateInspectionSettingStatusRequest): UpdateInspectionSettingStatusResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateInspectionSettingStatusWithOptions(request, runtime);
}

model UpdateInspectionThresholdRequest {
  operaUid?: string(name='OperaUid'),
  riskCode?: string(name='RiskCode'),
  thresholdItemListJson?: string(name='ThresholdItemListJson'),
}

model UpdateInspectionThresholdResponseBody = {
  code?: int32(name='Code'),
  data?: boolean(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model UpdateInspectionThresholdResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: UpdateInspectionThresholdResponseBody(name='body'),
}

async function updateInspectionThresholdWithOptions(request: UpdateInspectionThresholdRequest, runtime: Util.RuntimeOptions): UpdateInspectionThresholdResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.operaUid)) {
    body['OperaUid'] = request.operaUid;
  }
  if (!Util.isUnset(request.riskCode)) {
    body['RiskCode'] = request.riskCode;
  }
  if (!Util.isUnset(request.thresholdItemListJson)) {
    body['ThresholdItemListJson'] = request.thresholdItemListJson;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'UpdateInspectionThreshold',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function updateInspectionThreshold(request: UpdateInspectionThresholdRequest): UpdateInspectionThresholdResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateInspectionThresholdWithOptions(request, runtime);
}

model UpdateOperationPermissionRequest {
  permissionType?: int32(name='PermissionType'),
  switchFrontOperaUid?: string(name='SwitchFrontOperaUid'),
  uid?: long(name='Uid'),
}

model UpdateOperationPermissionResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model UpdateOperationPermissionResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: UpdateOperationPermissionResponseBody(name='body'),
}

async function updateOperationPermissionWithOptions(request: UpdateOperationPermissionRequest, runtime: Util.RuntimeOptions): UpdateOperationPermissionResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.permissionType)) {
    query['PermissionType'] = request.permissionType;
  }
  if (!Util.isUnset(request.switchFrontOperaUid)) {
    query['SwitchFrontOperaUid'] = request.switchFrontOperaUid;
  }
  if (!Util.isUnset(request.uid)) {
    query['Uid'] = request.uid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'UpdateOperationPermission',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function updateOperationPermission(request: UpdateOperationPermissionRequest): UpdateOperationPermissionResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateOperationPermissionWithOptions(request, runtime);
}

model UpdateReportEmailConfigStatusRequest {
  configStatus?: int32(name='ConfigStatus'),
  mailConfigId?: long(name='MailConfigId'),
  operaUid?: string(name='OperaUid'),
}

model UpdateReportEmailConfigStatusResponseBody = {
  code?: int32(name='Code'),
  data?: boolean(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model UpdateReportEmailConfigStatusResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: UpdateReportEmailConfigStatusResponseBody(name='body'),
}

async function updateReportEmailConfigStatusWithOptions(request: UpdateReportEmailConfigStatusRequest, runtime: Util.RuntimeOptions): UpdateReportEmailConfigStatusResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.configStatus)) {
    body['ConfigStatus'] = request.configStatus;
  }
  if (!Util.isUnset(request.mailConfigId)) {
    body['MailConfigId'] = request.mailConfigId;
  }
  if (!Util.isUnset(request.operaUid)) {
    body['OperaUid'] = request.operaUid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'UpdateReportEmailConfigStatus',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function updateReportEmailConfigStatus(request: UpdateReportEmailConfigStatusRequest): UpdateReportEmailConfigStatusResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateReportEmailConfigStatusWithOptions(request, runtime);
}

model UpdateReportSubscriptionRequest {
  dayOfWeek?: int32(name='DayOfWeek'),
  hourOfDay?: int32(name='HourOfDay'),
  operaUid?: string(name='OperaUid'),
  reportName?: string(name='ReportName'),
  subscribe?: int32(name='Subscribe'),
}

model UpdateReportSubscriptionResponseBody = {
  code?: int32(name='Code'),
  data?: boolean(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model UpdateReportSubscriptionResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: UpdateReportSubscriptionResponseBody(name='body'),
}

async function updateReportSubscriptionWithOptions(request: UpdateReportSubscriptionRequest, runtime: Util.RuntimeOptions): UpdateReportSubscriptionResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.dayOfWeek)) {
    body['DayOfWeek'] = request.dayOfWeek;
  }
  if (!Util.isUnset(request.hourOfDay)) {
    body['HourOfDay'] = request.hourOfDay;
  }
  if (!Util.isUnset(request.operaUid)) {
    body['OperaUid'] = request.operaUid;
  }
  if (!Util.isUnset(request.reportName)) {
    body['ReportName'] = request.reportName;
  }
  if (!Util.isUnset(request.subscribe)) {
    body['Subscribe'] = request.subscribe;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'UpdateReportSubscription',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function updateReportSubscription(request: UpdateReportSubscriptionRequest): UpdateReportSubscriptionResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateReportSubscriptionWithOptions(request, runtime);
}

model UpdateScenarioRequest {
  alertSettingId?: long(name='AlertSettingId'),
  id?: string(name='Id'),
  level?: long(name='Level'),
  name?: string(name='Name'),
  operaUid?: string(name='OperaUid'),
}

model UpdateScenarioResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  pageTotal?: long(name='PageTotal'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model UpdateScenarioResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: UpdateScenarioResponseBody(name='body'),
}

async function updateScenarioWithOptions(request: UpdateScenarioRequest, runtime: Util.RuntimeOptions): UpdateScenarioResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.alertSettingId)) {
    query['AlertSettingId'] = request.alertSettingId;
  }
  if (!Util.isUnset(request.id)) {
    query['Id'] = request.id;
  }
  if (!Util.isUnset(request.level)) {
    query['Level'] = request.level;
  }
  if (!Util.isUnset(request.name)) {
    query['Name'] = request.name;
  }
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'UpdateScenario',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function updateScenario(request: UpdateScenarioRequest): UpdateScenarioResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateScenarioWithOptions(request, runtime);
}

model UpdateSceneRequest {
  flowName?: string(name='FlowName'),
  metricListJson?: string(name='MetricListJson'),
  nodeListJson?: string(name='NodeListJson'),
  operaUid?: string(name='OperaUid'),
  sceneDesc?: string(name='SceneDesc'),
  sceneId?: long(name='SceneId'),
  sceneName?: string(name='SceneName'),
  sceneOwner?: string(name='SceneOwner'),
  sceneWebhook?: string(name='SceneWebhook'),
}

model UpdateSceneResponseBody = {
  code?: int32(name='Code'),
  data?: string(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model UpdateSceneResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: UpdateSceneResponseBody(name='body'),
}

async function updateSceneWithOptions(request: UpdateSceneRequest, runtime: Util.RuntimeOptions): UpdateSceneResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.flowName)) {
    body['FlowName'] = request.flowName;
  }
  if (!Util.isUnset(request.metricListJson)) {
    body['MetricListJson'] = request.metricListJson;
  }
  if (!Util.isUnset(request.nodeListJson)) {
    body['NodeListJson'] = request.nodeListJson;
  }
  if (!Util.isUnset(request.operaUid)) {
    body['OperaUid'] = request.operaUid;
  }
  if (!Util.isUnset(request.sceneDesc)) {
    body['SceneDesc'] = request.sceneDesc;
  }
  if (!Util.isUnset(request.sceneId)) {
    body['SceneId'] = request.sceneId;
  }
  if (!Util.isUnset(request.sceneName)) {
    body['SceneName'] = request.sceneName;
  }
  if (!Util.isUnset(request.sceneOwner)) {
    body['SceneOwner'] = request.sceneOwner;
  }
  if (!Util.isUnset(request.sceneWebhook)) {
    body['SceneWebhook'] = request.sceneWebhook;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'UpdateScene',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function updateScene(request: UpdateSceneRequest): UpdateSceneResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateSceneWithOptions(request, runtime);
}

model UpdateSceneModelRequest {
  fcFunctionName?: string(name='FcFunctionName'),
  fcHandler?: string(name='FcHandler'),
  fcInitializer?: string(name='FcInitializer'),
  fcRegionNo?: string(name='FcRegionNo'),
  fcServiceName?: string(name='FcServiceName'),
  modelDesc?: string(name='ModelDesc'),
  modelId?: long(name='ModelId'),
  modelLanguage?: int32(name='ModelLanguage'),
  modelMemo?: string(name='ModelMemo'),
  modelName?: string(name='ModelName'),
  modelType?: int32(name='ModelType'),
  operaUid?: string(name='OperaUid'),
  rootCauseDesc?: string(name='RootCauseDesc'),
  rootCauseSolution?: string(name='RootCauseSolution'),
}

model UpdateSceneModelResponseBody = {
  code?: int32(name='Code'),
  data?: string(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model UpdateSceneModelResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: UpdateSceneModelResponseBody(name='body'),
}

async function updateSceneModelWithOptions(request: UpdateSceneModelRequest, runtime: Util.RuntimeOptions): UpdateSceneModelResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.fcFunctionName)) {
    body['FcFunctionName'] = request.fcFunctionName;
  }
  if (!Util.isUnset(request.fcHandler)) {
    body['FcHandler'] = request.fcHandler;
  }
  if (!Util.isUnset(request.fcInitializer)) {
    body['FcInitializer'] = request.fcInitializer;
  }
  if (!Util.isUnset(request.fcRegionNo)) {
    body['FcRegionNo'] = request.fcRegionNo;
  }
  if (!Util.isUnset(request.fcServiceName)) {
    body['FcServiceName'] = request.fcServiceName;
  }
  if (!Util.isUnset(request.modelDesc)) {
    body['ModelDesc'] = request.modelDesc;
  }
  if (!Util.isUnset(request.modelId)) {
    body['ModelId'] = request.modelId;
  }
  if (!Util.isUnset(request.modelLanguage)) {
    body['ModelLanguage'] = request.modelLanguage;
  }
  if (!Util.isUnset(request.modelMemo)) {
    body['ModelMemo'] = request.modelMemo;
  }
  if (!Util.isUnset(request.modelName)) {
    body['ModelName'] = request.modelName;
  }
  if (!Util.isUnset(request.modelType)) {
    body['ModelType'] = request.modelType;
  }
  if (!Util.isUnset(request.operaUid)) {
    body['OperaUid'] = request.operaUid;
  }
  if (!Util.isUnset(request.rootCauseDesc)) {
    body['RootCauseDesc'] = request.rootCauseDesc;
  }
  if (!Util.isUnset(request.rootCauseSolution)) {
    body['RootCauseSolution'] = request.rootCauseSolution;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'UpdateSceneModel',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function updateSceneModel(request: UpdateSceneModelRequest): UpdateSceneModelResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateSceneModelWithOptions(request, runtime);
}

model UpdateSceneModelApplyRequest {
  applyContent?: string(name='ApplyContent'),
  applyId?: long(name='ApplyId'),
  applyStatus?: int32(name='ApplyStatus'),
  operaUid?: string(name='OperaUid'),
}

model UpdateSceneModelApplyResponseBody = {
  code?: int32(name='Code'),
  data?: string(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model UpdateSceneModelApplyResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: UpdateSceneModelApplyResponseBody(name='body'),
}

async function updateSceneModelApplyWithOptions(request: UpdateSceneModelApplyRequest, runtime: Util.RuntimeOptions): UpdateSceneModelApplyResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.applyContent)) {
    body['ApplyContent'] = request.applyContent;
  }
  if (!Util.isUnset(request.applyId)) {
    body['ApplyId'] = request.applyId;
  }
  if (!Util.isUnset(request.applyStatus)) {
    body['ApplyStatus'] = request.applyStatus;
  }
  if (!Util.isUnset(request.operaUid)) {
    body['OperaUid'] = request.operaUid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'UpdateSceneModelApply',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function updateSceneModelApply(request: UpdateSceneModelApplyRequest): UpdateSceneModelApplyResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateSceneModelApplyWithOptions(request, runtime);
}

model UpdateSceneModelCurVersionRequest {
  extId?: long(name='ExtId'),
  modelId?: long(name='ModelId'),
  operaUid?: string(name='OperaUid'),
}

model UpdateSceneModelCurVersionResponseBody = {
  code?: int32(name='Code'),
  data?: string(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model UpdateSceneModelCurVersionResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: UpdateSceneModelCurVersionResponseBody(name='body'),
}

async function updateSceneModelCurVersionWithOptions(request: UpdateSceneModelCurVersionRequest, runtime: Util.RuntimeOptions): UpdateSceneModelCurVersionResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.extId)) {
    body['ExtId'] = request.extId;
  }
  if (!Util.isUnset(request.modelId)) {
    body['ModelId'] = request.modelId;
  }
  if (!Util.isUnset(request.operaUid)) {
    body['OperaUid'] = request.operaUid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'UpdateSceneModelCurVersion',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function updateSceneModelCurVersion(request: UpdateSceneModelCurVersionRequest): UpdateSceneModelCurVersionResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateSceneModelCurVersionWithOptions(request, runtime);
}

model UpdateSceneSystemModelStatusRequest {
  modelId?: long(name='ModelId'),
  modelStatus?: int32(name='ModelStatus'),
  operaUid?: string(name='OperaUid'),
}

model UpdateSceneSystemModelStatusResponseBody = {
  code?: int32(name='Code'),
  data?: string(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model UpdateSceneSystemModelStatusResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: UpdateSceneSystemModelStatusResponseBody(name='body'),
}

async function updateSceneSystemModelStatusWithOptions(request: UpdateSceneSystemModelStatusRequest, runtime: Util.RuntimeOptions): UpdateSceneSystemModelStatusResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.modelId)) {
    body['ModelId'] = request.modelId;
  }
  if (!Util.isUnset(request.modelStatus)) {
    body['ModelStatus'] = request.modelStatus;
  }
  if (!Util.isUnset(request.operaUid)) {
    body['OperaUid'] = request.operaUid;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'UpdateSceneSystemModelStatus',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function updateSceneSystemModelStatus(request: UpdateSceneSystemModelStatusRequest): UpdateSceneSystemModelStatusResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateSceneSystemModelStatusWithOptions(request, runtime);
}

model UpdateScenestatusRequest {
  id?: int32(name='Id'),
  operaUid?: string(name='OperaUid'),
}

model UpdateScenestatusResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model UpdateScenestatusResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: UpdateScenestatusResponseBody(name='body'),
}

async function updateScenestatusWithOptions(request: UpdateScenestatusRequest, runtime: Util.RuntimeOptions): UpdateScenestatusResponse {
  Util.validateModel(request);
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'UpdateScenestatus',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function updateScenestatus(request: UpdateScenestatusRequest): UpdateScenestatusResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateScenestatusWithOptions(request, runtime);
}

model UpdateScriptRequest {
  handleSuggestDesc?: string(name='HandleSuggestDesc'),
  id?: int32(name='Id'),
  metricName?: string(name='MetricName'),
  operaUid?: string(name='OperaUid'),
  productCode?: string(name='ProductCode'),
  rootCauseDesc?: string(name='RootCauseDesc'),
  rootCausesLog?: string(name='RootCausesLog'),
  sceneId?: string(name='SceneId'),
  script?: string(name='Script'),
  scriptLanguage?: string(name='ScriptLanguage'),
  scriptName?: string(name='ScriptName'),
  status?: int32(name='Status'),
  type?: int32(name='Type'),
}

model UpdateScriptResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model UpdateScriptResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: UpdateScriptResponseBody(name='body'),
}

async function updateScriptWithOptions(request: UpdateScriptRequest, runtime: Util.RuntimeOptions): UpdateScriptResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.handleSuggestDesc)) {
    query['HandleSuggestDesc'] = request.handleSuggestDesc;
  }
  if (!Util.isUnset(request.id)) {
    query['Id'] = request.id;
  }
  if (!Util.isUnset(request.metricName)) {
    query['MetricName'] = request.metricName;
  }
  if (!Util.isUnset(request.operaUid)) {
    query['OperaUid'] = request.operaUid;
  }
  if (!Util.isUnset(request.productCode)) {
    query['ProductCode'] = request.productCode;
  }
  if (!Util.isUnset(request.rootCauseDesc)) {
    query['RootCauseDesc'] = request.rootCauseDesc;
  }
  if (!Util.isUnset(request.rootCausesLog)) {
    query['RootCausesLog'] = request.rootCausesLog;
  }
  if (!Util.isUnset(request.sceneId)) {
    query['SceneId'] = request.sceneId;
  }
  if (!Util.isUnset(request.script)) {
    query['Script'] = request.script;
  }
  if (!Util.isUnset(request.scriptLanguage)) {
    query['ScriptLanguage'] = request.scriptLanguage;
  }
  if (!Util.isUnset(request.scriptName)) {
    query['ScriptName'] = request.scriptName;
  }
  if (!Util.isUnset(request.status)) {
    query['Status'] = request.status;
  }
  if (!Util.isUnset(request.type)) {
    query['Type'] = request.type;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'UpdateScript',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function updateScript(request: UpdateScriptRequest): UpdateScriptResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateScriptWithOptions(request, runtime);
}

model UpdateStatusOfSceneRequest {
  operaUid?: string(name='OperaUid'),
  sceneId?: long(name='SceneId'),
  sceneStatus?: int32(name='SceneStatus'),
}

model UpdateStatusOfSceneResponseBody = {
  code?: int32(name='Code'),
  data?: string(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model UpdateStatusOfSceneResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: UpdateStatusOfSceneResponseBody(name='body'),
}

async function updateStatusOfSceneWithOptions(request: UpdateStatusOfSceneRequest, runtime: Util.RuntimeOptions): UpdateStatusOfSceneResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.operaUid)) {
    body['OperaUid'] = request.operaUid;
  }
  if (!Util.isUnset(request.sceneId)) {
    body['SceneId'] = request.sceneId;
  }
  if (!Util.isUnset(request.sceneStatus)) {
    body['SceneStatus'] = request.sceneStatus;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'UpdateStatusOfScene',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function updateStatusOfScene(request: UpdateStatusOfSceneRequest): UpdateStatusOfSceneResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateStatusOfSceneWithOptions(request, runtime);
}

model UpdateTagInfoRequest {
  operaUid?: string(name='OperaUid'),
  tagId?: long(name='TagId'),
  tagName?: string(name='TagName'),
}

model UpdateTagInfoResponseBody = {
  code?: int32(name='Code'),
  data?: map[string]any(name='Data'),
  msg?: string(name='Msg'),
  requestId?: string(name='RequestId'),
  status?: string(name='Status'),
}

model UpdateTagInfoResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: UpdateTagInfoResponseBody(name='body'),
}

async function updateTagInfoWithOptions(request: UpdateTagInfoRequest, runtime: Util.RuntimeOptions): UpdateTagInfoResponse {
  Util.validateModel(request);
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'UpdateTagInfo',
    version = '2020-08-06',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function updateTagInfo(request: UpdateTagInfoRequest): UpdateTagInfoResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateTagInfoWithOptions(request, runtime);
}

